Définitions
- Un tableau est une collection de variables (appelées cellules ou cases) accessibles directement à partir de leurs positions (indice ou suite d’indices) dans le tableau.
- En Java un tableau (array en anglais) est le type d’objet le plus simple à programmer pour gérer un ensemble d’éléments :
- Les éléments d’un tableau sont tous du même type.
- Ces éléments peuvent être des données de type primitif ou des références d’une classe donnée.
- La taille d’un tableau est déterminée lors de sa création et ne peut être modifiée par la suite. Chaque tableau a un champ public length contenant sa taille.
- La position d’un élément dans un tableau est déterminée avec un indice entier.
- L’indice du premier élément d’un tableau est toujours 0 et l’indice du der-nier élément d’un tableau est le nombre d’éléments du tableau moins 1.
- La JVM vérifie à l’exécution que l’indice utilisé pour accéder à un élément figure bien dans l’intervalle autorisé et que le.type d’un objet à stocker est compatible avec le type du tableau.
Un tableau Java est un objet qui mémorise un ensemble de valeurs contiguës en mémoire, aux-quelles on accède grâce à un indice entier compris entre 0 et le nombre d’éléments moins un. Un tableau qui contient des valeurs de type primitif, comme le tableau nombresPremiers, stocke directement ses valeurs les unes après les autres, tandis que celui qui contient des objets, comme le tableau lettres, stocke les références sur ses objets.
Déclarer et créer un tableau
Déclarer et créer un tableau
- Du point de vue de sa création, un tableau se comporte comme un objet. Aussi, la création d’un tableau se déroule en deux temps : la déclaration d’une variable de type tableau, et la création du tableau proprement dit.
- Voici comment se déclare une référence tableauElements de type tableau :
TypeElement [] tabl eauElements
TypeElement peut être un type primitif ou une classe. TypeElement peut être utilisé aussi comme type de paramètre ou comme type de retour d’une méthode retournant un tableau. Comme toute référence, une référence de type tableau peut être égale à nul 1 ou désigner un objet tableau.
On peut effectuer la création et l’initialisation d’un objet tableau de trois façons.
- Lors de la déclaration du tableau si les valeurs initiales des éléments à stocker sont connues. La liste de ces valeurs est citée entre accolades après l’opérateur =.
Exemple:
int [] nombresPremiers = {1, 2, 3, 5, 7, 11, 13, 17};
String [] smileys = {";)",":(", ":0"};
- A tout moment, en utilisant l’opérateur new et la taille voulue du table-an Les éléments sont alors initialisés avec leur valeur par défaut (0 pour les éléments de type numérique ou caractère, fal se pour les éléments 1/4it type bool ean et null pour les éléments de type objet). Un tableau peir avoir une taille nulle, ce qui correspond à un ensemble vide.
Exemple:
float [] tabNombres = new float [5];
String [] textes;
// int taille = 10;
textes = new String [taille];
- À tout moment, en utilisant l’opérateur new et une liste entre accolades de valeurs. Cette notation est très pratique pour passer un tableau en paramètre à une méthode sans qu’il faille créer une variable locale pour ce tableau.
Exemple:
char lettreT = 't';
char lettre = 'o';
String s = new String ( new char [] {lettreT, lettre0, lettreT, lettre0});
Utiliser un tableau
- Une fois que l’on a créé un objet tableau, pour consulter ou modifier un ment on utilise son indice dans le tableau cité entre [].
L’utilisation d’un tableau pour lequel l’espace n’a pas été alloué provoque la levée d’une exception NullPointerException
- Les éléments d’un tableau sont indicés à partir de 0.
- Chaque élément peut être accédé individuellement en donnant le nom du tableau suivi de l’indice entre [ ]
Exemple:
Déclaration: tab = new int [10];// tab est un tableau à une dimension de 10 int
tab [0] ;// premier élément du tableau tab
tab [9] ;// dernier élément du tableau tab
L’accès à un élément du tableau en dehors des bornes provoque la levée d’une exception ArrayIndexOutOfBoundsException
En tant qu’objet Java, un tableau hérite de la classe java.lang.Object et de toutes ses méthodes.
-
La méthode clone est notamment redéfinie pour retourner une copie du tableau.
- En revanche, la méthode equals n’est pas reéfinie pour comparer le contenu de deux tableaux.
- La méthode toString n’est pas non plus redéfinie pour renvoyer la liste des valeurs.
Si vous tentez de stocker dans un tableau un objet dont le type est incompatible avec celui du tableau, une exception java.lang.ArrayStoreException est déclenchée.
Tableau à plusieurs dimensions
Déclaration
La déclaration d’un tableau à plusieurs dimensions précise et fixe :
- le nombre de dimensions du tableau ;
- le type des éléments `a stocker dans le tableau.
- Lors d’une définition de tableau le nombre de crochets indique le nombre de dimensions du tableau.
- Un tableau à plusieurs dimensions, ou matrice, représente un rectangle composé de lignes et de colonnes.
Chaque élément stockée dans le tableau est adressé par sa position, donnée par sa ligne et
sa colonne. En Java, si tab est un tableau à deux dimensions, l’élément de ligne i et colonne j est désigné par tab[i][j].
- En Java, les tableaux à plusieurs dimensions sont en fait des tableaux de tableaux.
- L’exemple suivante définit un tableau à 2 dimensions 5 lignes sur 10 colonnes ( ou l’inverse ).
int t2[][] = new int[5][10] ;
Exemple, pour allouer une matrice de 5 lignes de 6 colonnes :
int[][] matrice=new int[5][];
for (int i=0 ; i<matrice.length; i++)
matrice[i]=new int[6];
Java permet de résumer l’opération précédente en :
int[][] matrice=new int[5][6];
Toutes les lignes d’un tableau à 2 dimensions n’ont pas forcément le même nombre d’éléments :
Chaque ajout du symbole [] permet d’obtenir une dimension supplémentaire :
int [] t; // une dimension
int [] [] m; // deux dimensions
char [] [] [] p; // trois dimensions
int t22[][] ;
t22 = new int[5][];
for( int i = 0; i< t22.length; ++i){
t22[i]= new int [i+1];
}
for( int i = 0; i< t22.length; ++i){
for( int j = 0; j<t22[i].length; ++j){
//accès à t22[i][j]
}
}Exercice d’application
Créer un tableau d’entiers à deux dimensions, avec 3 lignes et 5 colonnes. Après création,modifier l’élément de la ligne 1 et colonne 2 par t[1][2] = 7.
Réponse
int [][] t = new int [3][5]; // 3 lignes, 5 colonnes
t[1][2] = 7;
Parcours des matrices
- Les parcours des matrices se font souvent avec des boucles imbriquées : une boucle externe pour parcourir les lignes, pour des indices compris entre 0 et mat.lenght-1, et une boucle interne qui, pour chaque ligne, fait le parcours des éléments dans toutes les colonnes de cette ligne. Les indices des colonnes seront alors compris entre 0 et mat[i].lenght-1.
Exemple:
Initialisation d’une matrice par saisie de sa taille et de ses éléments.
public class initMatrice {
public static void main (String args[]) {
int n,m;
Terminal.ecrireString("Nombre de lignes? ");
n = Terminal.lireInt();
Terminal.ecrireString("Nombre de colonnes? ");
m = Terminal.lireInt();
int [][] mat = new int [n][m];
// Initialisation
for (int i=0; i<= mat.length -1; i++) {
for (int j=0; j<= mat[i].length -1; j++) {
Terminal.ecrireString("Element (" + i + ", " + j + ")? ");
mat[i][j] = Terminal.lireInt();
}
}
}
}
Exercice d’application
Gestion des notes par élèves. Ce programme initialise une matrice de n élèves avec m notes par élève, puis calcule dans un tableau de taille n, la moyenne de chaque élève. Les notes de l’élève i se trouvent à la ligne i de la matrice notes, alors que sa moyenne est dans moyennes[i].
Réponse
public class matriceNotes {
public static void main (String args[]) {
int n,m;
Terminal.ecrireString("Nombre d’eleves? ");
n = Terminal.lireInt();
Terminal.ecrireString("Nombre de notes par eleve? ");
m = Terminal.lireInt();
double [][] notes = new double [n][m];
double [] moyennes = new double [n];
// Initialisation
for (int i=0; i<= notes.length -1; i++) {
Terminal.ecrireStringln("Notes pour l’eleve "+ (i+1)+ "?");
for (int j=0; j<= notes[i].length -1; j++) {
Terminal.ecrireString(" Note "+ (j+1) + "? ");
notes[i][j] = Terminal.lireDouble();
}
}
// Calcul des moyennes
for (int i=0; i<= notes.length -1; i++) {
for (int j=0; j<= notes[i].length -1; j++) {
moyennes[i] = moyennes[i] + notes[i][j];
}
moyennes[i] = moyennes[i]/notes[i].length;
}
//Affichages
for (int i=0; i<= moyennes.length -1; i++) {
Terminal.ecrireString("Moyenne de l’eleve "+ (i+1) + "= ");
Terminal.ecrireDoubleln(moyennes[i]);
}
}
}
Copie de tableaux
- La copie d’un tableau dans l’autre peut toujours se faire par itération sur les éléments du premier tableau, et recopie dans le second. Cela dit, l’API standard de Java nous fournit une méthode particulièrement rapide, qui fonctionne par copie de zone mémoire, sur le modèle du clonage d’objets.
- La méthode à invoquer est System.arraycopy, dont voici la signature.
public static void arraycopy(Object src, int src_pos, Object dest, int dest_pos, int length)
Les objets src et dest doivent être des tableaux de même type, sans quoi une exception est générée. Ces deux tableaux doivent avoir été correctement déclarés et initialisés.
Lors de cette opération, la machine Java va tenter de copier length éléments du tableau src à partir de l’index src_pos, vers le tableau dest, à partir de l’index dest_pos. Si un dépassement de capacité a lieu, une exception est générée. Ce dépassement peut avoir lieu en lecture (si src_pos + length dépasse la taille du tableau src), ou en écriture (si dest_pos + length dépasse la taille du tableau dest).
<exemple
int tab1 [] = new int [] {0, 1, 2, 3, 4, 5} ;
int tab2 [] = new int [] {0, 10, 20, 30, 40} ;
System.arraycopy(tab1, 1, tab2, 1, 2) ;
. . .
…
…
|
