Les tableaux en Java

Ce matériel couvre les notions fondamentales des tableaux en Java, destinées aux étudiants débutants en programmation Java. Il explique la déclaration, l'initialisation, l'utilisation et la manipulation des tableaux unidimensionnels et multidimensionnels, ainsi que les techniques pour parcourir et rechercher des éléments dans ces structures.

Les tableaux en Java : définition et déclaration

En programmation Java, un tableau est une variable particulière qui peut contenir plusieurs valeurs ordonnées séquentiellement. Chaque valeur est accessible via un indice, appelé aussi compteur. Contrairement aux variables simples qui ne contiennent qu'une seule valeur, un tableau permet de stocker plusieurs éléments du même type.

La déclaration d'un tableau suit cette syntaxe :

<type du tableau> <nom du tableau>[] = { <contenu du tableau> };

Par exemple :

int tableauEntier[] = {0,1,2,3,4,5,6,7,8,9};
double tableauDouble[] = {0.0,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0};
char tableauCaractere[] = {'a','b','c','d','e','f','g'};
String tableauChaine[] = {"chaine1", "chaine2", "chaine3", "chaine4"};

On remarque que pour un tableau de caractères, on utilise des apostrophes ' ', et pour un tableau de chaînes de caractères, des guillemets " ".

Il est aussi possible de déclarer un tableau vide avec une taille fixe :

int tableauEntier[] = new int[6];
// ou
int[] tableauEntier2 = new int[6];

Les tableaux multidimensionnels

Un tableau multidimensionnel est un tableau contenant plusieurs tableaux. Par exemple, un tableau à deux dimensions peut être vu comme un tableau de tableaux.

Exemple d'un tableau à deux dimensions contenant deux lignes : la première avec les premiers nombres pairs, la deuxième avec les premiers nombres impairs :

int premiersNombres[][] = { {0,2,4,6,8}, {1,3,5,7,9} };

On accède aux éléments via deux indices : le premier pour la ligne, le second pour la colonne. Par exemple :

• premiersNombres[0][0] correspond au premier élément de la ligne des nombres pairs (0).
• premiersNombres[1][0] correspond au premier élément de la ligne des nombres impairs (1).

Utilisation et parcours d'un tableau unidimensionnel

Un tableau commence toujours à l'indice 0. Par exemple, pour afficher la lettre 'a' dans un tableau de caractères :

System.out.println(tableauCaractere[0]);

Un tableau de 4 éléments aura donc des indices allant de 0 à 3 inclus.

Pour parcourir un tableau et afficher tous ses éléments, on utilise une boucle for avec la propriété length qui donne la taille du tableau :

char tableauCaractere[] = {'a','b','c','d','e','f','g'};

for(int i = 0; i < tableauCaractere.length; i++) {
  System.out.println("À l'emplacement " + i + " du tableau nous avons = " + tableauCaractere[i]);
}

Ce code affiche :

À l'emplacement 0 du tableau nous avons = a
À l'emplacement 1 du tableau nous avons = b
À l'emplacement 2 du tableau nous avons = c
À l'emplacement 3 du tableau nous avons = d
À l'emplacement 4 du tableau nous avons = e
À l'emplacement 5 du tableau nous avons = f
À l'emplacement 6 du tableau nous avons = g

Exemple de recherche dans un tableau

Voici un exemple de programme qui demande à l'utilisateur de saisir une lettre et recherche si cette lettre est présente dans un tableau de caractères. Le programme répète la demande tant que la lettre n'est pas trouvée, puis propose de recommencer.

char tableauCaractere[] = {'a', 'b', 'c', 'd', 'e', 'f', 'g'};
int i = 0;
char reponse = ' ', carac = ' ';
Scanner sc = new Scanner(System.in);

do { // Boucle principale
  do { // Répète tant que la lettre n'est pas dans le tableau
    i = 0;
    System.out.println("Rentrez une lettre en minuscule, SVP ");
    carac = sc.nextLine().charAt(0);
    // Recherche dans le tableau
    while(i < tableauCaractere.length && carac != tableauCaractere[i])
      i++;
    if (i < tableauCaractere.length)
      System.out.println(" La lettre " + carac + " se trouve bien dans le tableau !");
    else
      System.out.println(" La lettre " + carac + " ne se trouve pas dans le tableau !");
  } while(i >= tableauCaractere.length);

  do {
    System.out.println("Voulez-vous essayer à nouveau ? (O/N)");
    reponse = sc.nextLine().charAt(0);
  } while(reponse != 'N' && reponse != 'O');
} while (reponse == 'O');

System.out.println("Au revoir !");

Ce programme illustre l'importance de réinitialiser l'indice i à 0 avant chaque recherche pour parcourir le tableau depuis le début.

Gestion des erreurs liées aux indices

Une erreur fréquente est l'accès à un indice hors limites, ce qui provoque une exception java.lang.ArrayIndexOutOfBoundsException. Par exemple :

String[] str = new String[10];
// L'instruction suivante déclenche une exception
// Car on tente d'écrire à l'indice 10, alors que les indices vont de 0 à 9
str[10] = "Une exception";

Parcours d'un tableau bidimensionnel

Pour parcourir un tableau à deux dimensions, on utilise deux boucles imbriquées, une pour chaque dimension.

Exemple avec des boucles while :

int premiersNombres[][] = { {0,2,4,6,8}, {1,3,5,7,9} };
int i = 0, j = 0;

while (i < 2) {
  j = 0;
  while (j < 5) {
    System.out.print(premiersNombres[i][j]);
    j++;
  }
  System.out.println("");
  i++;
}

Ce code affiche d'abord la ligne des nombres pairs, puis celle des nombres impairs.

Le même résultat peut être obtenu avec des boucles for :

int premiersNombres[][] = { {0,2,4,6,8}, {1,3,5,7,9} };

for(int i = 0; i < 2; i++) {
  for(int j = 0; j < 5; j++) {
    System.out.print(premiersNombres[i][j]);
  }
  System.out.println("");
}

Syntaxe simplifiée du for-each (JDK 1.5 et plus)

Java propose une syntaxe simplifiée pour parcourir les tableaux, appelée for-each, qui évite la gestion explicite des indices :

String tab[] = {"toto", "titi", "tutu", "tete", "tata"};

for(String str : tab)
  System.out.println(str);

À chaque itération, la variable str contient la valeur courante du tableau.

Pour un tableau à deux dimensions, la première boucle for-each retourne un sous-tableau, qu'il faut ensuite parcourir avec une deuxième boucle :

String tab[][] = {{"toto", "titi", "tutu", "tete", "tata"}, {"1", "2", "3", "4"}};
int i = 0, j = 0;

for(String sousTab[] : tab) {
  i = 0;
  for(String str : sousTab) {
    System.out.println("La valeur de la nouvelle boucle est  : " + str);
    System.out.println("La valeur du tableau à l'indice [" + j + "][" + i + "] est : " + tab[j][i]);
    i++;
  }
  j++;
}

Glossaire des termes clés

• Tableau : variable contenant plusieurs données du même type, accessibles via des indices.
• Indice : position d'un élément dans un tableau, commençant toujours à 0.
• Tableau unidimensionnel : tableau simple avec une seule dimension (une seule série d'indices).
• Tableau multidimensionnel : tableau contenant plusieurs tableaux, par exemple un tableau à deux dimensions.
• longueur (length) : propriété d'un tableau indiquant le nombre d'éléments qu'il contient.
• Boucle for : structure de contrôle permettant de répéter une action un nombre déterminé de fois.
• Boucle for-each : syntaxe simplifiée pour parcourir un tableau sans gérer explicitement les indices.
• Exception ArrayIndexOutOfBoundsException : erreur levée lorsqu'on tente d'accéder à un indice hors limites du tableau.

Points clés à retenir

• Un tableau est une variable qui peut contenir plusieurs valeurs du même type, accessibles par un indice.
• La déclaration d'un tableau utilise des crochets [] après le nom ou le type.
• Les indices commencent toujours à 0 et vont jusqu'à length - 1.
• Les tableaux multidimensionnels sont des tableaux de tableaux, accessibles avec plusieurs indices.
• Pour parcourir un tableau, on utilise généralement une boucle for avec la propriété length.
• La syntaxe for-each simplifie le parcours des tableaux unidimensionnels et multidimensionnels.
• Il faut toujours faire attention à ne pas dépasser les limites du tableau pour éviter des exceptions.
• Lors d'une recherche dans un tableau, il est important de réinitialiser l'indice avant chaque nouvelle recherche.