Les tableaux Java

Un tableau en Java est un conteneur de taille fixe qui contient une séquence de valeurs du même type. Une fois créé, sa longueur ne change jamais, et chaque case peut stocker exactement une valeur — un int, une String, une référence vers n'importe quel objet, tout ce qui correspond au type déclaré.

Les tableaux constituent la base sur laquelle reposent les autres collections Java (ArrayList, HashMap, etc.). Ils sont moins ergonomiques que ces classes de plus haut niveau, mais ils sont rapides, prévisibles, et vous les verrez partout — dans les arguments de méthodes, les valeurs de retour et le code sensible aux performances.

Déclarer un tableau

Le type d'un tableau est le type de l'élément suivi de [] :

int[] scores;       // an array of ints
String[] names;     // an array of String references
double[] prices;    // an array of doubles

Les crochets peuvent aussi se placer après le nom de la variable — int scores[]; — mais la forme int[] scores est de loin la plus courante et celle que vous devriez utiliser.

Déclarer une variable ne crée pas encore de tableau ; cela donne simplement à Java un emplacement qui peut contenir une référence vers un tableau. Cet emplacement démarre à null.

Créer un tableau avec new

Pour allouer réellement le tableau, utilisez new avec une longueur :

int[] scores = new int[5];

Cela réserve de l'espace pour 5 ints. Java initialise chaque case à la valeur par défaut du type :

• types numériques → 0 (ou 0.0)
• boolean → false
• char → '�' (le caractère nul, point de code 0 — pas un espace)
• types référence → null

Ainsi, scores contient immédiatement {0, 0, 0, 0, 0}. Il n'existe pas d'état « non initialisé » — une fois le tableau créé, chaque position a une valeur définie.

Littéraux de tableau

Lorsque vous connaissez le contenu à l'avance, utilisez un littéral :

int[] scores = {90, 85, 73, 100, 62};
String[] colors = {"red", "green", "blue"};

La longueur est déduite du nombre d'éléments. Cette forme n'est valide que sur la même ligne que la déclaration — vous ne pouvez pas écrire scores = {90, 85}; plus tard. Pour cela, utilisez la forme explicite :

scores = new int[]{90, 85, 73, 100, 62};

Accéder aux éléments

Vous lisez et écrivez des éléments par index à base zéro, en utilisant des crochets :

int[] scores = {90, 85, 73, 100, 62};
System.out.println(scores[0]);   // 90
System.out.println(scores[4]);   // 62
scores[2] = 80;                  // replace 73 with 80

Les index valides vont de 0 à length - 1. Un index hors limites lève une ArrayIndexOutOfBoundsException à l'exécution — Java ne retourne pas silencieusement une valeur par défaut et ne fait pas de bouclage.

La propriété length

Chaque tableau possède un champ length public et en lecture seule qui indique sa taille :

int[] scores = {90, 85, 73, 100, 62};
System.out.println(scores.length);   // 5

Notez qu'il s'agit d'un champ, pas d'une méthode — pas de parenthèses. C'est l'une des petites particularités de Java : les chaînes utilisent .length(), les tableaux utilisent .length. Ils se comportent aussi différemment des collections (list.size()). Ces formes sont faciles à confondre ; le compilateur vous le signalera.

length est fixée à la création. Pour « agrandir » un tableau, vous devez en allouer un nouveau et copier les données — voir le chapitre Copier les tableaux.

Les tableaux stockent des références, pas des copies

Lorsque le type d'élément est un objet, le tableau stocke des références, pas les objets eux-mêmes :

String[] colors = {"red", "green", "blue"};
String first = colors[0];
// first and colors[0] both reference the same "red" string

Pour les types primitifs, cette distinction n'a pas d'importance — les valeurs int sont copiées en entrée et en sortie. Pour les objets, modifier un élément depuis l'extérieur du tableau modifie ce que le tableau voit, car ils partagent la même référence.

Valeurs par défaut et tableaux null

Une variable de tableau déclarée mais non assignée vaut null, et lire .length ou tout index dessus lève une NullPointerException :

int[] data;            // not initialized
// System.out.println(data.length);  // would throw NullPointerException
data = new int[3];
System.out.println(data.length);     // 3

Un tableau vide — de longueur zéro — est un tableau parfaitement valide, et c'est généralement ce que vous souhaitez renvoyer pour une valeur « vide », plutôt que null :

int[] none = new int[0];
System.out.println(none.length);     // 0

Un exemple complet

Afficher un tableau

Une surprise fréquente : passer un tableau directement à System.out.println n'affiche pas son contenu. Cela affiche le type du tableau et son hash d'identité :

int[] scores = {90, 85, 73};
System.out.println(scores);   // e.g. [I@39ed3c8d  — not the values!

Le [I signifie « tableau d'int », et la partie hexadécimale est un hash d'identité, pas des données. Pour voir les éléments, utilisez Arrays.toString du package java.util :

import java.util.Arrays;

int[] scores = {90, 85, 73};
System.out.println(Arrays.toString(scores));   // [90, 85, 73]

Pour les tableaux imbriqués (multi-dimensionnels), utilisez Arrays.deepToString à la place.

Et ensuite

Vous savez créer un tableau et accéder à ses éléments par index. La prochaine étape est l'itération — parcourir chaque élément à tour de rôle avec les boucles sur les tableaux, sans avoir à écrire scores[0], scores[1], scores[2] un par un.

Entraînement