La boucle for en Java

La boucle for est le moteur de l'itération en Java. Elle regroupe trois éléments — ce qu'il faut faire avant la boucle, ce qu'il faut vérifier avant chaque itération, et ce qu'il faut faire après chaque itération — dans un seul en-tête. Le résultat est plus compact et moins sujet aux erreurs que la même chose écrite avec while.

Syntaxe

for (initialization; condition; update) {
  // body
}

Trois parties séparées par des points-virgules :

1. Initialisation — s'exécute une seule fois, avant le démarrage de la boucle. Déclare généralement le compteur.
2. Condition — vérifiée avant chaque itération. Si elle est fausse, la boucle se termine.
3. Mise à jour — s'exécute après chaque itération. Incrémente généralement le compteur.

for (int i = 0; i < 5; i++) {
  System.out.println(i);
}

Affiche 0 1 2 3 4. L'en-tête se lit ainsi : commencer avec i = 0, exécuter tant que i < 5, incrémenter i à chaque fois.

Forme équivalente avec while

Une boucle for est mécaniquement équivalente à ce while :

{
  int i = 0;            // initialization
  while (i < 5) {       // condition
    System.out.println(i);
    i++;                // update
  }
}

L'avantage du for est que tout ce qui contrôle la boucle se trouve sur une seule ligne, ce qui rend l'intention évidente au premier coup d'œil.

Variantes de comptage

L'en-tête du for est flexible. Les trois parties peuvent être n'importe quoi :

// counting down
for (int i = 10; i > 0; i--) { ... }

// stepping by 2
for (int i = 0; i < 100; i += 2) { ... }

// looping over an array by index
for (int i = 0; i < arr.length; i++) {
  System.out.println(arr[i]);
}

Si vous n'avez pas besoin d'une partie particulière, omettez-la — mais conservez les points-virgules :

for (;;) {              // identical to while (true)
  if (done()) break;
}

Le piège du décalage d'un

Le bug le plus courant avec la boucle for est de choisir le mauvais opérateur de comparaison. Lors de l'indexation d'un tableau de longueur n, les indices valides vont de 0 à n - 1, donc la condition doit être i < n (et non i <= n) :

int[] arr = {10, 20, 30};   // length 3, indices 0..2
for (int i = 0; i <= arr.length; i++) {
  System.out.println(arr[i]);   // throws ArrayIndexOutOfBoundsException when i == 3
}

Remplacer <= par < corrige le problème. Une règle simple : utilisez < avec un compteur ou une length, et réservez <= pour une dernière valeur explicite (ex. for (int i = 1; i <= 5; i++)).

Portée de la variable de boucle

Une variable déclarée dans la clause d'initialisation est locale à la boucle. Une fois la boucle terminée, elle disparaît :

for (int i = 0; i < 5; i++) {
  // i is visible here
}
// i is not visible here

C'est voulu — cela vous empêche de dépendre accidentellement de la valeur finale du compteur. Si vous avez besoin de la valeur en dehors de la boucle, déclarez-la au préalable :

int i;
for (i = 0; i < 5; i++) {
  if (someCondition(i)) break;
}
System.out.println("stopped at i=" + i);

Plusieurs variables dans un seul en-tête

Vous pouvez déclarer et mettre à jour plusieurs variables, séparées par des virgules :

for (int i = 0, j = 10; i < j; i++, j--) {
  System.out.println(i + " " + j);
}

C'est occasionnellement utile — mais si une boucle nécessite plus de deux variables qui interagissent, c'est généralement le signe qu'il faut refactoriser en éléments plus petits.

Quand choisir for plutôt que while

Utilisez une boucle for lorsque vous savez — ou pouvez exprimer en une ligne — combien d'itérations vous avez besoin ou quelle plage vous parcourez. Utilisez une boucle while lorsque la condition d'arrêt est détachée d'un compteur (ex. « jusqu'à ce que l'entrée soit épuisée », « jusqu'au succès »).

Pour parcourir un tableau ou une collection élément par élément, la boucle for-each améliorée est presque toujours plus lisible.

Un exemple concret

La suite

Quand vous souhaitez simplement parcourir chaque élément d'un tableau ou d'une collection sans gérer d'index, la boucle for-each est l'outil approprié.

Pratique