Licence 1 MASS, parcours SEMS et ESD Introduction `a Java et `a l’algorithmique
S´ebastien Verel verel@i3s.unice.fr
http://www.i3s.unice.fr/∼verel
´Equipe ScoBi - Universit´e Nice Sophia Antipolis
8 mars 2013
Synth` ese
El`eves pour la synth`ese du jour ?
Objectifs de la s´ eance 5
1 Lire et enregistrer une valeur dans un tableau
2 Recherche des valeurs extr´emales d’un tableau
3 Utilisation d’un accumulateur pour r´ealiser un calcul dans un tableau
4 Savoir concevoir un jeu de tests pour un algorithme
5 Savoir inspecter les valeurs de certaines donn´ees d’un algorithme
Questions principales du jour :
A quoi ¸ca sert ?
float moyenne(int n1, int n2, int n3, int n4, int n5, int n6, int n7, int n8, int n9, int n10, int n11, int n12) {
float m = (n1 + n2 + n3 + n4 + n5 + n6 +
n7 + n8 + n9 + n10 + n11 + n12 ) / 12 ; return m;
}
Ce n’est pas tenable :
Finalement souvenez-vous (cm04)
float moyenne(int n) { float m, a ;
for(int i = 0; i < n; i++) { a = lire("Entrer une note");
m = m + a ; }
m = m / n ; return m;
Finalement souvenez-vous (cm04)
float moyenne(int n) { float m, a ;
m = 0;
for(int i = 0; i < n; i++) { a = lire("Entrer une note");
m = m + a ; }
return m / n;
}
Mais :
algorithme effectue deux choses :
Vers une solution
Noter (enregistrer) les notes quelque part : float moyenne(??? notes)
notes:
12 8 17 5 16 18 18 11 14 12
Possibilit´e de les lire de nouveau : Persistence des donn´ees
Plan
1 Introduction
2 D´efinition de la structure
3 Algorithmes sur les tableaux
Besoin en tableaux
Le besoin de stocker pour traiter les donn´ees sont ´enormes : les images : tableau en deux dimensions
r´epertoire de noms les factures
les calendriers
les num´eros de t´el´ephones les placards
...
Caract´ eristiques de ces structures de donn´ ees
0 1 2 3 4 5 6 7 8
12 3 4 78 12 3 9 11 12 De taille finie :
le nombre maximum de donn´ees est d´etermin´ee les donn´ees sont ”num´erotables” : indexables
lecture de donn´ees dont l’indice (le rang) est d´etermin´e
D´ eclaration tableau en JAVA / processing
D´eclaration d’un tableau type[] t ;
type : int, float, double, char, String, boolean, etc.
Les [] indique que la variable est de type tableau t: nom du tableau
En Java : d´ eclaration et initialisation
D´eclaration et initialisation
type[] t = { val0, val1, val2, ... , valn };
type : int, float, double, char, String, boolean, etc.
les [] : indique que la variable est de type tableau Toutes les valeurs des cases du tableau sont donn´ees en extension
D´ eclaration et initialisation : exemples
int[] notes = { 12, 8, 17, 5, 16, 18, 18, 11, 14, 12 };
String[] phrase = { "rien", "ne", "vaut", "un",
"bon", "exemple" };
Un truc g´ enial en Java
Taille du tableau t.length
Exemple :
int[] notes = { 12, 8, 17, 5, 16, 18, 18, 11, 14, 12 };
print(notes.length);
Remarques
Donn´ees d’un tableau : de mˆeme type
Taille du tableau : nombre maximal de donn´ee que peut contenir le tableau
Taille est d´etermin´e avant l’utilisation du tableau Taille est fixe
D´ eclaration et initialisation vide
D´eclaration et initialisation avec la valeur nulle de taille n type[] t = new type[n];
type : int, float, double, char, String, boolean, etc.
les [] : indique que la variable est de type tableau
new: indique qu’il faut r´eserver de la m´emoire de l’ordinateur n: nombre entier indiquant la taille
D´ eclaration et initialisation vide : Exemple
int[] t = new int[100];
int n = 55;
boolean[] table = new boolean[n];
Tableau et d´ eclaration de m´ ethode
D´eclaration de m´ethode dont un param`etre est de type tableau :
float moyenne(int[] notes)
D´eclaration de m´ethode dont la valeur finale est de type tableau :
int[] saisirTableau(int n) { ...
}
Lecture des valeurs
lecture de la valeur d’indicei du tableaut t[i]
0 1 2 3 4 5 6 7 8
12 3 4 78 12 3 9 11 12 t[3] a pour valeur 78
tous lest[.] sont des variables classiques :
Remarques
Beaucoup de langage de programmation ont pour convention que nous adopterons.
Supposons que la taille du tableau estn.
indice 0 : premier ´el´ement du tableau indice n−1 : dernier indice du taille
Cons´equence : il n’est pas possible de lire une donn´ee en dehors des bornes (t[n+ 1],t[n] out[−1])
ATTENTION :
Il n’est pas possible d’acc´eder `a tous les ´el´ements du tableau en mˆeme temps : seulement ´el´ement par ´el´ement (traitement s´equenciel)
Remarques
0 1 2 3 4 5 6 7 8
12 3 4 78 12 3 9 11 12
i = 3 ;
”la case apr`es i”
t[ i + 1 ]
12
”la case avant i”
Affectation des valeurs
Affectation de la valeura`a la case d’indice i du tableaut t[i] = a
0 1 2 3 4 5 6 7 8
12 3 4 78 12 3 9 11 12
t[3] = 15 t[2] = t[0]
t[8] = t[1]2+ 1
Remarques sur l’affectation
int[] t = new int[5] ; t[0] = 3
t[1] = 6 t[2] = 98 t[3] = 23 t[4] = 91
t[0] se comporte comme une variable “classique”
“La case d’avant i re¸coit la casei” : i = 3
t[i - 1] = t[i]
Quand utiliser un tableau ?
Les questions que l’on doit se poser :
Le nombre de donn´ees est-il d´etermin´e `a l’avance ?
Le nombre maximal de donn´ees est-il d´etermin´e `a l’avance ? Les donn´ees ont-elles besoin d’ˆetre index´ees (num´erot´ees) ? A-t-on besoin d’acc´eder `a une donn´ee dont l’indexe doit ˆetre d´etermin´e ?
Si oui, oui, oui, oui,
il est surement conseill´e d’utiliser un tableau
Lecture et affectation
Lecture :
println(t[0]);
int a = t[3] + 1;
Affectation : t[4] = 8;
int i = 3;
t[i] = t[i - 1] + 1;
Souvenir de CM04
Port´ee des variables locales
les variables locales (m,a eti) ne sont accessibles que dans cet algorithme, c’est-`a-dire entre d´ebut et fin.
Algorithme moyenne(n : entier) : r´eel d´ebut
variablem,a : r´eel variablei : entier ...
retourner m fin
moyenne(5)
Souvenir de CM04
Port´e des variables locales
Les valeurs des variables locales n’alt`erent pas les valeurs des variables portant le mˆeme nom `a l’ext´erieur de l’algorithme.
variablem : r´eel m ←2
moyenne(5) m ←m+ 3
´
ecrire(m)
Tableaux et m´ ethodes
void test(int[] t) { t[1] = 20;
}
void setup() {
int[] tab = {16, 9, 17, 18};
test(tab);
println(tab[1]);
}
Qu’est-ce qui s’affiche ?
Tableaux et m´ ethodes
Les valeurs contenues dans un tableau donn´e en param`etre peuvent ˆetre modifi´ees par une m´ethode
dansint[] t
test une adresse vers une zone m´emoire o`u sont contenus les
´el´ements du tableau d’entier
L’adresse tn’est pas modifi´ee par la m´ethode Mais la zone m´emoire peut ˆetre modifi´ee
It´ eration et tableaux
L’it´eration devient l’outil indispensable pour parcourir un tableau.
/*******************************************
* affichage d’un tableau contenant des chaines de caracteres
*
* entree :
* - t : tableau de chaines de caracteres
*
* sortie :
* - aucune
*******************************************/
void afficher(String[] t) {
En Java
void afficher(String[] t) {
for(int i = 0; i < t.length; i++) println(t[i]);
}
void setup() {
String[] phrase = { "rien", "ne", "vaut", "un",
"bon", "exemple" };
afficher(phrase);
It´ eration et tableaux : saisie au clavier, lecture
/*******************************************
* lecture au clavier d’un tableau de nombres reels
*
* entree :
* - n : taille du tableau
*
* sortie :
* - tableau de nombres entiers
*******************************************/
int[] lecture(int n) {
It´ eration et tableaux : saisie au clavier, lecture
int[] lecture(int n) { int[] t = new int[n];
for(int i = 0; i < t.length; i++) t[i] = lire("Entrer un nombre");
return t;
}
Ex´ ecution de la m´ ethode
void setup() { int n = 3;
int[] t = lecture(n);
affiche(t);
}
Calcul de la moyenne
/*******************************************
* calcul de la moyenne des nombres du tableau
*
* entree :
* - t : tableau d’entiers
*
* sortie :
* - moyenne des nombres
*******************************************/
Calcul de la moyenne
float moyenne(int[] t) { float m;
m = 0;
for(int i = 0; i < t.length; i++) m = m + t[i];
m = m / t.length;
return m;
Ex´ ecution de la m´ ethode
void setup() { int n = 3;
int[] t = lecture(n);
println("la moyenne est " + moyenne(t));
}
Utilisation d’un accumulateur
Comme dans le cas de calcul de la moyenne,
un certain nombre d’algorithmes n´ecessite de m´emoriser un calcul partiel.
On nomme souvent paraccumulateur la variable qui permet de m´emoriser ce r´esultat.
ATTENTION !
Il faut toujours affecter une valeur initiale (initialiser) `a
Somme des carr´ es
CalculerSn=Pn−1 k=0u2k
o`u uk est enregistr´e `a l’incidek du tableaut :
/*******************************************
* calcul de la somme des carres des nombres du tableau
*
* entree :
* - t : tableau de reels
*
* sortie :
* - somme des carres
Somme des carr´ es
float sommeCarre(float[] t) { float m;
m = 0;
for(int i = 0; i < t.length; i++) m = m + t[i] * t[i];
return m;
}
Element maximum
Trouver le maximum des ´el´ements d’un tableau
/*******************************************
* calcul le nombre maximum du tableau
* le tableau ne doit pas etre vide
*
* entree :
* - t : tableau de reels
*
* sortie :
* - maximum
Element maximum
float maxTab(float[] t) { float m;
m = t[0];
for(int i = 1; i < t.length; i++) if (m < t[i])
m = t[i];
return m;
}
void setup() {
Affichage d’une image avec Processing : image
// declaration et chargement de l’image au format jpeg PImage img = loadImage("DSC00024.JPG");
// taille de l’ecran size(400,300);
// position du coin superieure gauche // et dimensions de l’affichage
image(img, 0, 0, width, height);
Exercice
Afficher successivement les images marey 0.gif, marey 1.gif, ..., marey 9.gif
