En Java, un tableau est un objet.
Les éléments d’un tableaux doivent tous être du même type.
1) Déclaration, initialisation, traitement :
Aux chapitres précédents, nous avons vu que nous pouvons déclarer et utiliser un tableau de réels comme suit : double[] taille = {1.76, 1.68, 1.89, 1.72, 1.54,
1.78, 1.34, 1.78 };
et que cette déclaration crée un objet de la taille de 8 réels (type double) et initialise les valeurs du tableau.
double[] taille; /* déclaration d’une variable de référence sur un tableau des réels */
La liste de valeurs entre les accolades est une liste
d’initialisation. L’utilisation d’une liste d’initialisation n’est permise que lors de la déclaration d’un tableau.
Celle-ci permet la création implicite d’un objet dont la taille correspond exactement au nombre d’éléments de la liste.
L’affectation place donc une référence vers le nouvel objet dans la variable de référence taille.
Chaque élément du tableau est accessible à travers son indice.
Nous accédons à une valeur du tableau en spécifiant son indice entre des crochets.
Ex. : taille[0] est le premier élément du tableau taille, c’est une variable de type double ayant comme valeur 1.76.
On peut illustrer le tableau des tailles par le schéma
suivant :
taille
1.76 1.68 1.89 1.72 1.54 1.78 1.34 1.78
1. L'indice commence par 0 (zéro)
2. La boucle for est largement utilisée pour traiter les tableaux.
3. La longueur (le nombre d’éléments) du tableau est déterminée par taille.length qui vaut 8
4. Sur l'en-tête d'une méthode : un paramètre de type tableau est représenté par le type, le nom, crochet ouvert puis crochet fermé :
static double moyenne( double taille[], int nbPers) etc . . .
static void afficher( double [] taille, int nbPers) etc . . .
Exemple : déterminer la taille la plus petite : double plusPetiteTaille = Double.MAX_VALUE ; for (int i = 0 ; i < taille.length ; i++) if ( taille[i] < plusPetiteTaille)
plusPetiteTaille = taille[i];
Remarques :
Avec les crochets placés tout de suite après le type : int[] age = {23, 12, 27 },
nbCafe = { 3, 5, 0 } ;
int [] représente le « type tableau d’entiers » et age, nbCafe sont deux tableaux d’entiers.
Avec les crochets non placés tout de suite après le type :
int age[] = {23, 12, 27 }, nbFem = 2 ;
age est un tableau d’entiers mais nbFem est une variable simple de type entier.
Autre façons de déclarer et créer le tableau taille :
double[] taille = new double[8];
Nous pouvons ensuite initialiser les 8 valeurs du tableau en accédant chaque élément et en affectant la valeur désirée, par exemple :
taille[0] = 1.76;
taille[1] = 1.68;
taille[2] = 1.89;
taille[3] = 1.72;
taille[4] = 1.54;
taille[5] = 1.78;
taille[6] = 1.34;
taille[7] = 1.78;
Donc, le nom du tableau (taille) est une variable de référence vers un objet de type tableau de double.
La déclaration de taille et la création de l’objet sont donc 2 étapes distinctes.
Contrairement au langage C (et C++), le nom d’un tableau n’est pas considéré comme une constante.
double[] tab2;
tab2 = taille;
Cette affectation est valide, tab2 et taille sont maintenant des alias pour le même objet.
Taille d’un tableau :
Chaque objet tableau possède une constante publique nommée length qui stocke la taille du tableau.
Elle est référencée en se servant du nom du tableau (comme pour tout autre objet)::
Ex Ex : taille.length: taille.length contient la valeur 8 contient la valeur 8
Cette valeur correspond au nombre maximum d’élément pouvant être placé Cette valeur correspond au nombre maximum d’élément pouvant être placé dans le tableau, il est possible qu’il y ait moins d’élément valide que dans le tableau, il est possible qu’il y ait moins d’élément valide que cela, il faut alors conserver explicitement le nombre d’éléments valides cela, il faut alors conserver explicitement le nombre d’éléments valides grâce à une variable entière.
grâce à une variable entière.
Passage d’un tableau en paramètre à une méthode Passage d’un tableau en paramètre à une méthode
::Comme tout objet, un tableau peut être passé en paramètre à une méthode.
Comme tout objet, un tableau peut être passé en paramètre à une méthode.
Exemple 1 Exemple 1 ::
Soit la méthode suivante Soit la méthode suivante ::
double plusPetit ( double[] tab) double plusPetit ( double[] tab) {
{
double min = Double.MAX_VALUE;double min = Double.MAX_VALUE;
for(int i = 0; i < tab.length; i++)for(int i = 0; i < tab.length; i++)
if( tab[i] < min)if( tab[i] < min)
min = tab[i];min = tab[i];
return min;return min;
} }
et soit l’appel de cette méthode comme suit : et soit l’appel de cette méthode comme suit : double plusPetiteTaille = plusPetit( taille);
double plusPetiteTaille = plusPetit( taille);
Lors de l’appel, taille et tab deviennent des alias pour le même objet Lors de l’appel, taille et tab deviennent des alias pour le même objet (le tableau).
(le tableau).
Donc, un changement dans le contenu de tab dans la méthode se reflétera Donc, un changement dans le contenu de tab dans la méthode se reflétera à travers la variable de référence taille.
à travers la variable de référence taille.
Exercice Exercice ::
Soit la méthode suivante Soit la méthode suivante ::
void changement( int[] t1, int[] t2) void changement( int[] t1, int[] t2) { t1 = t2;
{ t1 = t2;
t1[0] = t2[t2.length – 1]; t1[0] = t2[t2.length – 1];
}}
Et les déclarations et instructions suivantes Et les déclarations et instructions suivantes :: int[] numero = { 1, 3, 4, 5 };
int[] numero = { 1, 3, 4, 5 };
int[] num = { 4, 3, 6};
int[] num = { 4, 3, 6};
changement(numero, num);
changement(numero, num);
Que contiennent les tableaux numero et num après cet appel?
Que contiennent les tableaux numero et num après cet appel?
Solution Solution :: Avant l’appel Avant l’appel ::
11 33 4 4 5 5
numero
Au début
Au début de la méthode changement :
11 33 4 4 55
t1
t1 et t2 deviennent des alias de numero et num.
après l’instruction t1 = t2;t1 = t2;
1 1 3 3 44 55
Après t1[0] = t2[t2.length – 1];t1[0] = t2[t2.length – 1];
4 3 6
4 3 6
4 3 6
6 3 6
t2 num
num
t1 num numero
t2
num
t1
t2
numero
après l’exécution de la méthode
2) Tri d'un tableau
(mettre ses valeurs en ordre)
Le but d'un tri est de mettre en ordre les valeurs des éléments d'un tableau. Dans le cours IFT 1870, on présente une seule méthode de tri : le tri par sélection. Une autre méthode qui est plus rapide (le tri rapide "Quick Sort") sera présentée après l’intra.
Pour comprendre cette méthode de tri, on observe un tableau T qui contient 5 entiers ( nbElement vaut 5 ) :
t[0] t[1] t[2] t[3] t[4]
Avant tri 50 25 34 17 48 Après tri 17 25 34 48 50
L'indice i = 0 :
Quelle sera la valeur à placer à l'indice 0 ? C'est 17 à l'indice 3.
Comment trouver l'indice 3 qui est l'indice contenant la valeur minimale (indMin) ?
On initialise cet indice à i : indMin = i ; /* qui est zéro */
On compare t[indMin] avec le reste : t[1], t[2], ..., t[4].
Quand on découvre une valeur qui est encore petite on ajuste la valeur de indMin :
Pour j varie de 1 à 4 Faire
1 1 33 44 55
6 3 6
numero
num
Si t[j] < t[indMin] Alors indMin = j
j vaut 1 : t[1] < t[0] ? <==> 25 < 50 ?
Oui ==> indMin = 1
j vaut 2 : t[2] < t[1] ? <==> 34 < 25 ? Non ==> on ne modifie pas indMin j vaut 3 : t[3] < t[1] ? <==> 17 < 25 ? Oui ==> indMin = 3
j vaut 4 : t[4] < t[3] ? <==> 48 < 17 ? Non ==> on ne modifie pas indMin Après avoir comparé avec le reste, indMin vaut 3.
Est-il le même indice que i qui vaut 0 ? Non. On échange (permute) t[0] et t[3] : échanger (permuter) t[0] et t[3]
--- | | v v
t[0] t[1] t[2] t[3] t[4]
Avant tri 50 25 34 17 48 Après i=0 17 25 34 50 48
La valeur la plus petite (17) se trouve à sa bonne position (ici à l'indice 0).
L'indice i = 1 :
Quelle sera la valeur à placer à l'indice 1 ? C'est 25 à l'indice 1 (lui-même).
Comment trouver l'indice 1 qui est l'indice contenant la valeur minimale (indMin) ?
On initialise cet indice à i : indMin = i ; /* qui est un */
On compare t[indMin] avec le reste : t[2], t[3], ..., t[4].
Quand on découvre une valeur qui est encore petite
on ajuste la valeur de indMin :
Pour j varie de 2 à 4 Faire Si t[j] < t[indMin] Alors indMin = j
j vaut 2 : t[2] < t[1] ? <==> 34 < 25 ?
Non ==> on ne modifie pas indMin j vaut 3 : t[3] < t[1] ? <==> 50 < 25 ? Non ==> on ne modifie pas indMin j vaut 4 : t[4] < t[3] ? <==> 48 < 25 ? Non ==> on ne modifie pas indMin Après avoir comparé avec le reste, indMin vaut 1.
Est-il le même indice que i qui vaut 1 ?
Oui. On n'échange pas, il est déjà à la bonne place.
t[0] t[1] t[2] t[3] t[4]
Avant tri 50 25 34 17 48 Après i=1 17 25 34 50 48
Il suffit de continuer avec i=2, i = 3
Pour un tableau de 5 éléments, quand on a déjà mis en ordre les 4 premiers éléments, le cinquième est le plus grand.
Résumé de l'algorithme pour trier un tableau t : /* Du premier à avant-dernier élément Faire : */
Pour i varie de 0 à Nb_Elemt-2 Faire Début
indMin <---- i
/* Comparer avec le reste pour ajuster indMin */
Pour j varie de i+1 à nbElement -1 Faire Si t[j] < t[indMin] Alors
indMin <---j
/* Permuter, si nécessaire, t[i] et t[indMin] */
Si indMin est différent de i Alors Permuter t[i] et t[indMin]
Fin
Permutation du contenu de deux variables :
Suppossons qu'on ait deux variables de même type A et B (ici de même type "int") dont A vaut 15 et B vaut 5 :
int A = 15, B = 5;
Permuter A et B provoque le changement du contenu de ces variables : A vaudra 5 et B vaudra 15 après une bonne permutation.
Observons la proposition suivante:
A = B ; B = A ;
Avec A = B ; on dépose B comme nouvelle valeur de A.
A vaut maintenant 5.
Avec B = A ; on dépose A comme nouvelle valeur de B.
B vaut maintenant 5.
Ainsi A vaut 5 et B vaut 5. Ce n'est pas du tout une permutation.
Pour permuter un verre de vin et un verre d'eau on ne
verse jamais de l'eau dans le vin ( A = B ;). On utilise plutôt un troisième verre (un verre temporaire).
Les schémas et étapes sont présentés en classe.
Pour permuter A (vaut 15) et B (vaut 5) : int A = 15, B = 5, tempo;
tempo = A ; A = B ; B = tempo;
On utilise ainsi une variable temporaire et trois
affectations pour permuter le contenu de deux variables
de même type.
Exemple:
L’exemple suivant permet de :
- déclarer deux tableaux (age et sexe) d’au maximum 10 personnes - saisir le nombre de personnes traitées et remplir les 2 tableaux
avec des données tapées au clavier - trier les tableaux selon les âges
- afficher les informations avant et après le tri
import java.io.*;
public class Tableau {
static int saisir(int [] age, char [] sexe, int borne) throws IOException
{
int n ; // le nombre de personnes à traiter boolean valide ;
do {
n = Utile.lireEntier("Entrez le nombre de personnes a traiter" + "(entre 1 et " + borne +") ");
valide = n >= 1 && n <= borne ; if ( !valide )
System.out.println("Valeur invalide! Retapez SVP ");
} while (!valide);
for (int i = 0 ; i < n ; i++) {
age[i] = Utile.lireEntier("Entrez l'age de la personne " + (i+1) + " ");
sexe[i] = Utile.lireCaractere("Entrez un caractere pour le " + "sexe de la personne " + (i+1) + " ");
if (sexe[i] >= 'a' && sexe[i] <= 'z') sexe[i] += 'A' - 'a';
}
return n;
}
static void afficher(int [] age, char [] sexe, int nbPers, String message)
{
System.out.println("\nInformations des personnes " + message + " le tri : ");
for (int i = 0 ; i < nbPers ; i++){
Utile.afficher(i+1, 3);
System.out.print(") ");
System.out.print( (sexe[i] == 'F') ? "feminin " : "masculin");
Utile.afficher(age[i], 8);
System.out.println();
}
System.out.println();
}
static void echanger(int [] t, int i, int indMin) { int tempo = t[i];
t[i] = t[indMin];
t[indMin] = tempo;
}
static void echanger(char [] t, int i, int indMin) { char tempo = t[i];
t[i] = t[indMin];
t[indMin] = tempo;
}
static void trier(int [] age, char [] sexe, int nbPers) { for (int i = 0 ; i < nbPers-1 ; i++) {
int indMin = i ;
for (int j = i+1; j < nbPers ; j++) if ( age[j] < age[indMin] )
indMin = j;
if (indMin != i) {
echanger(age, i, indMin);
echanger(sexe, i, indMin);
} }
}
public static void main (String[] args) throws IOException
{ final int MAX_PERS = 10 ; // au maximum 10 personnes à traiter int [] age = new int[MAX_PERS];
char [] sexe = new char [MAX_PERS];
int nbPers = saisir(age, sexe, MAX_PERS);
afficher(age, sexe, nbPers, "avant");
trier(age, sexe, nbPers);
afficher(age, sexe, nbPers, "apres");
} }
/* Exécution:
Entrez le nombre de personnes a traiter(entre 1 et 10) 3 Entrez l'age de la personne 1 25
Entrez un caractere pour le sexe de la personne 1 f Entrez l'age de la personne 2 18
Entrez un caractere pour le sexe de la personne 2 f Entrez l'age de la personne 3 29
Entrez un caractere pour le sexe de la personne 3 m Informations des personnes avant le tri :
1) feminin 25 2) feminin 18 3) masculin 29
Informations des personnes apres le tri : 1) feminin 18
2) feminin 25 3) masculin 29
*/
3) Exemples sur tableaux classiques à un seul indice :
/**
* Fichier Tableau1.java * IFT 1170, hiver 2003
* Matière de base : tableaux avec des valeurs primitives (int,
* double, char, ...)
* méthodes (fonctions en C)
* traitements de base d'un tableau
* Plusieurs commentaires "pédagogiques" pour expliquer certaines
* nouveautés * Observations :
* 1. on peut écrire une méthode AVANT ou APRÈS son appel
* 2. sur l'en-tête d'une méthode : crochets [] sont avant ou
* après un tableau
* 3. Dans la classe Integer :
* public final static int MAX_VALUE; entier le plus grand * public final static int MIN_VALUE; entier le plus petit * etc . . .
*/
public class Tableau1 {
// afficher le contenu d'un tableau avec un en-tête approprié /* \n new line => changement de ligne, \t : tabulateur */
public static void afficher( int[] tab, String message) {
System.out.println("\nLe contenu du tableau " + message + " : ");
for(int i = 0; i < tab.length; i++)
System.out.println(i+1 + ")\t" + tab[i]);
System.out.println();
}
// méthode permettant de calculer et de retourner la moyenne des // valeurs d'1 tableau
public static double moyenne(int tab []) {
double total=0.0;
for(int i = 0; i < tab.length; i++) total += tab[i];
return total / tab.length;
} // méthode principale:
public static void main (String[] args)
{
// déclarer + d'initialiser 2 tableaux d'entiers:
int[] age = { 20, 19, 33, 50, 43, 25, 29, 38},
nbCafe = { 3, 5, 7, 2, 8 }; // nb. de tasses de café consommé
System.out.println("Le plus vieux a " + plusGrand(age) + " ans");
System.out.println("Le nombre plus eleve de tasses de cafe « <
+ " consomme : " + plusGrand(nbCafe) );
afficher(age, "des ages avant modifications");
System.out.println("Le plus jeune a " + plusPetit(age) + " ans");
System.out.println("L'age moyen est : " + moyenne(age) + " ans");
System.out.println("La plus faible consommation : " + plusPetit(nbCafe) +
" tasse(s) de cafe par jour");
System.out.println("Le nombre moyen de tasses de cafe consomme" + " est : " + moyenne(nbCafe) );
dixAnsPlusTard(age);
afficher(age, "des ages 10 ans apres");
}
// Integer.MIN_VALUE : constante statique de type int de la classe // Integer. C'est l'entier le plus petit.
public static int plusGrand(int[] tab) {
int max = Integer.MIN_VALUE; // l'entier le plus petit
for(int i = 0; i < tab.length; i++) if ( tab[i] > max)
max = tab[i];
return max;
}
/* la modification sera conservée dans le tableau : à la sortie, la valeur de chacun des éléments du tableau s'ajoute 10 */
public static void dixAnsPlusTard(int[] tab) {
for(int i = 0; i < tab.length; i++) tab[i] += 10;
}
// méthode permettant de calculer+retourner la plus petite valeur public static int plusPetit(int[] tab)
{
int min = Integer.MAX_VALUE;
for(int i = 0; i < tab.length; i++) if ( tab[i] < min)
min = tab[i];
return min;
}
}
/* Exécution :
Le plus vieux a 50 ans
Le nombre plus eleve de tasses de cafe consomme : 8 Le contenu du tableau des ages avant modifications : 1) 20
2) 19 3) 33 4) 50 5) 43 6) 25 7) 29 8) 38
Le plus jeune a 19 ans
L'age moyen est : 32.125 ans
La plus faible consommation : 2 tasse(s) de cafe par jour Le nombre moyen de tasses de cafe consomme est : 5.0 Le contenu du tableau des ages 10 ans apres :
1) 30 2) 29 3) 43 4) 60 5) 53 6) 35 7) 39 8) 48
*/
4) Solution avec plusieurs classes et moins de méthodes statiques :
// classe tableau des entiers : c'est encore incomplète mais illustre // assez bien les notions de méthodes d'une classe
public class TabEntier
{
private int maxElement, // le nombre maximum d'éléments
nbElem; // le nombre effectif d'éléments d'un tableau private int [] tableau;
// construire un tableau avec des zéros partout : 1 démo.
public TabEntier(int maxElem) { maxElement = maxElem;
tableau = new int[maxElem];
// construire à partir d'un tableau déjà initialisé (cas de l'exemple) public TabEntier(int [] tab) {
maxElement = tab.length;
nbElem = tab.length;
tableau = new int[maxElement];
for (int i = 0 ; i < nbElem ; i++) tableau[i] = tab[i];
}
// afficher son contenu : \t pour tabulateur public void afficher(String nom) {
System.out.println("\nContenu du tableau " + nom + " : ");
for (int i = 0 ; i < nbElem ; i++)
System.out.println((i+1) + ")\t" + tableau[i]);
System.out.println();
}
// déterminer + retourner la plus grande valeur du tableau public int plusGrand()
{ int max = Integer.MIN_VALUE; // l'entier le plus petit
for(int i = 0; i < nbElem; i++) if ( tableau[i] > max) max = tableau[i];
return max;
}
// déterminer + retourner la plus petite valeur du tableau public int plusPetit()
{
int min = Integer.MAX_VALUE; // l'entier le plus grand
for(int i = 0; i < nbElem; i++) if ( tableau[i] < min) min = tableau[i];
return min;
}
// déterminer + retourner la moyenne du tableau public double moyenne()
{
double total=0.0;
for(int i = 0; i < nbElem; i++) total += tableau[i];
return total / nbElem;
}
// ajouter une quantite à chaque élément du tableau public void ajouter (int quantite) {
for (int i = 0 ; i < nbElem ; i++)
tableau[i] += quantite;
}
// autres constructeurs + méthodes ? : à votre imagination }
/** Fichier Tableau2.java
* IFT 1170, hiver 2003, semaine du 27 janvier
* Dans la fichier Tableau1.java, on travaille avec une seule classe * Tableau1.java.
* C'est l'étape "transition" entre la programmation traditionnelle
* et la POO:
* on apprend la base du Java avec des tableaux primitifs, méthodes
* vs fonctions en C, clause static, etc ....
* C'est le niveau attendu pour le numéro 1 du Tp1 (une seule
* classe)
* Ce projet fait la même chose que Tableau1.java mais avec 2
* classes au lieu d'une:
* - la classe TabEntier permettant de gérer un tableau d'entiers
* - la classe Tableau2.java permettant de tester le bon
* fonctionnement de TabEntier.
* C'est le niveau attendu pour les numéros 2 et 3 du Tp1 (plus
* d'une classe)
* Explications : semaine du 21 janvier */
public class Tableau2
{
public static void main (String[] args) {
// déclarer + d'initialiser 2 tableaux d'entiers:
int[] age = { 20, 19, 33, 50, 43, 25, 29, 38},
nbCafe = { 3, 5, 7, 2, 8 }; // nb. de tasses de café consommé TabEntier tabAge = new TabEntier(age);
TabEntier tabNbCafe = new TabEntier(nbCafe);
System.out.println("Le plus vieux a " + tabAge.plusGrand() + " ans");
System.out.println("Le nombre plus eleve de tasses de cafe consomme : " + tabNbCafe.plusGrand() );
tabAge.afficher("des ages avant modifications");
System.out.println("Le plus jeune a " + tabAge.plusPetit() + " ans");
System.out.println("L'age moyen est : " + tabAge.moyenne() + " ans");
System.out.println("La plus faible consommation : "
+ tabNbCafe.plusPetit()
+ " tasse(s) de cafe par jour");
System.out.println("Le nombre moyen de tasses de cafe
consomme est : " + tabNbCafe.moyenne() );
tabAge.ajouter(10);
tabAge.afficher("des ages 10 ans apres");
} }
/* Exécution avec 2 classes : TabEntier et Tableau2.java Le plus vieux a 50 ans
Le nombre plus eleve de tasses de cafe consomme : 8 Contenu du tableau des ages avant modifications : 1) 20
2) 19 3) 33 4) 50 5) 43 6) 25 7) 29 8) 38
Le plus jeune a 19 ans
L'age moyen est : 32.125 ans
La plus faible consommation : 2 tasse(s) de cafe par jour Le nombre moyen de tasses de cafe consomme est : 5.0 Contenu du tableau des ages 10 ans apres :
1) 30 2) 29 3) 43 4) 60 5) 53 6) 35 7) 39 8) 48
*/
