Parcourir les tableaux Java en boucle

Lire array[0], array[1], array[2] à la main cesse d'être pratique dès que la longueur dépasse 3. Une fois que vous avez créé un tableau, Java vous offre plusieurs façons de visiter chaque élément — choisissez celle qui correspond à ce que vous souhaitez réellement faire. Cette page couvre la boucle for basée sur l'index, la boucle for améliorée (for-each), les streams sur les tableaux, et comment choisir entre eux.

La boucle for classique

La boucle for basée sur l'index est la forme la plus flexible, et c'est la seule qui vous donne la position à laquelle vous vous trouvez :

int[] scores = {90, 85, 73, 100, 62};
for (int i = 0; i < scores.length; i++) {
  System.out.println(i + ": " + scores[i]);
}

Utilisez-la lorsque vous avez besoin :

• de l'index (pour l'afficher, comparer des voisins, sauter en avant)
• de parcourir le tableau en sens inverse — for (int i = scores.length - 1; i >= 0; i--)
• d'avancer de plus d'un pas — i += 2
• de modifier le tableau — en assignant à scores[i]

La borne est toujours i < array.length, jamais un nombre codé en dur. Si le tableau change de taille plus tard (ou est passé depuis ailleurs), la boucle fonctionne toujours.

length est un champ, donc il n'y a pas de parenthèses : écrivez scores.length, pas scores.length(). (Les chaînes de caractères sont différentes — String a une méthode length().) Quand le tableau est vide, length vaut 0 et le corps de la boucle ne s'exécute jamais, ce qui est exactement ce que vous voulez — aucune vérification spéciale nécessaire. Consultez le chapitre sur la boucle for pour les mécanismes généraux.

La boucle for améliorée — "for-each"

Lorsque vous n'avez besoin que de la valeur de chaque élément dans l'ordre, la boucle for améliorée est plus courte et plus claire :

int[] scores = {90, 85, 73, 100, 62};
int sum = 0;
for (int score : scores) {
  sum += score;
}
System.out.println("sum = " + sum);

Lisez le deux-points comme "dans" : "pour chaque int score dans scores." La variable de boucle est une copie fraîche de chaque élément. Vous ne pouvez pas obtenir l'index de cette façon, et vous ne pouvez pas modifier le tableau via score — assigner à score ne fait que relier la variable locale.

Utilisez la boucle for améliorée pour "faire quelque chose avec chaque valeur." Utilisez la boucle for classique chaque fois que l'index est important.

Lecture vs. écriture dans une boucle

Dans une boucle for classique, array[i] = newValue modifie le tableau en place :

int[] scores = {90, 85, 73, 100, 62};
for (int i = 0; i < scores.length; i++) {
  scores[i] = scores[i] + 5;     // give everyone a 5-point bonus
}

La boucle for améliorée ne peut pas faire cela pour les types primitifs — score = score + 5 ne modifie que la copie locale :

for (int score : scores) {
  score = score + 5;             // no effect on scores
}

Pour les tableaux d'objets, la variable de boucle référence toujours le même objet que l'emplacement du tableau, donc appeler des méthodes mutantes sur lui modifie bien ce que le tableau voit. Mais réassigner la variable ne le fait pas.

Les streams sur les tableaux

Pour les tableaux numériques, l'utilitaire Arrays.stream(...) vous donne une API de style pipeline :

import java.util.Arrays;

int[] scores = {90, 85, 73, 100, 62};
int total = Arrays.stream(scores).sum();
double avg  = Arrays.stream(scores).average().orElse(0);
int max     = Arrays.stream(scores).max().orElse(0);

Pour les tableaux d'objets, Arrays.stream(...) retourne un Stream<T> avec les méthodes habituelles filter/map/reduce :

String[] names = {"Ada", "Linus", "Grace"};
long shortOnes = Arrays.stream(names).filter(n -> n.length() <= 3).count();

Les streams sont expressifs mais pas gratuits — pour les boucles internes serrées, un simple for est plus rapide et plus facile à déboguer. Utilisez les streams quand l'intention (somme, filtre-puis-comptage, regroupement, transformation) est ce que vous voulez rendre évident. Consultez les streams Java pour l'API de pipeline complète.

forEach côté tableau

Il n'existe pas de array.forEach(...). Les équivalents les plus proches sont Arrays.stream(arr).forEach(...) (numérique ou objet) ou, pour les tableaux d'objets, le raccourci Arrays.asList(arr).forEach(...). La plupart du temps, la boucle for classique ou améliorée suffit — n'utilisez pas forEach juste pour une syntaxe différente.

Choisir une boucle

Un exemple pratique

Et ensuite

Vous pouvez maintenant créer des tableaux et les parcourir dans tous les sens. Les données du monde réel sont souvent bidimensionnelles — une grille, un tableau, un plateau de jeu — et Java prend cela en charge avec les tableaux multidimensionnels, qui sont en réalité des tableaux de tableaux.

Exercices