Boucle for-each en Java : syntaxe, exemples et pièges

Quand l'index ne fait que gêner

Une boucle for à compteur vous donne un compteur, une condition et une étape de mise à jour. Mais une grande partie du temps, la position d'un élément ne vous intéresse pas vraiment : vous voulez seulement faire quelque chose avec chacun, dans l'ordre, du début à la fin. Gérer un index pour cela, c'est du travail inutile, et c'est exactement là que les erreurs de décalage d'un cran (off-by-one) se glissent.

La boucle for-each (Java l'appelle le for amélioré) supprime complètement le compteur. Vous nommez une variable, vous la pointez vers une collection, et la boucle vous remet chaque élément à tour de rôle.

Syntaxe de base

La forme est for (Type element : collection). Lisez les deux-points comme le mot « dans » :

public class Main {
    public static void main(String[] args) {
        int[] scores = {88, 92, 75, 100};

        for (int score : scores) {
            System.out.println("Score: " + score);
        }
    }
}

Il n'y a pas de i, pas de scores.length, pas de scores[i]. À chaque passage, score est l'élément suivant. La boucle s'exécute une fois par élément et s'arrête automatiquement quand il n'y en a plus : vous ne pouvez ni dépasser la fin ni commencer un élément trop tôt.

Parcourir une liste

La même boucle fonctionne sur tout ce qui est itérable, ce qui inclut List, Set et les autres types de collection. Le type de l'élément se place avant le nom de la variable :

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> langs = List.of("Java", "Python", "Go");

        for (String lang : langs) {
            System.out.println(lang + " has " + lang.length() + " letters");
        }
    }
}

Remarquez que vous n'avez pas eu à savoir ni à vous soucier de savoir si langs repose sur un tableau, une liste chaînée ou autre chose : le for-each fonctionne de la même façon sur toutes. C'est là sa vraie force : une syntaxe lisible pour chaque collection.

var vous évite d'écrire le nom du type

Si le type de l'élément est long ou évident, var laisse le compilateur le déduire pour ne pas vous répéter :

import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> ages = Map.of("Ann", 30, "Bo", 25);

        for (var entry : ages.entrySet()) {
            System.out.println(entry.getKey() + " is " + entry.getValue());
        }
    }
}

Sans var, cette variable de boucle serait l'imprononçable Map.Entry<String, Integer>. var la garde lisible, et le type reste entièrement vérifié à la compilation : ce n'est pas un type souple et dynamique.

Le piège de la modification

Voici la règle qui piège tout le monde : vous ne pouvez pas ajouter ni retirer d'éléments d'une collection pendant qu'une boucle for-each la parcourt. Le faire lève une ConcurrentModificationException :

List<String> items = new ArrayList<>(List.of("a", "b", "c"));

for (String item : items) {
    if (item.equals("b")) {
        items.remove(item);   // lève ConcurrentModificationException
    }
}

La boucle remarque que la liste a changé sous elle et s'interrompt plutôt que de sauter ou de répéter des éléments en silence. Pour supprimer en toute sécurité, descendez jusqu'à un Iterator explicite, qui possède un remove() que la boucle connaît :

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> items = new ArrayList<>(List.of("a", "b", "c"));

        Iterator<String> it = items.iterator();
        while (it.hasNext()) {
            if (it.next().equals("b")) {
                it.remove();   // sûr
            }
        }

        System.out.println(items);   // [a, c]
    }
}

Un raccourci courant est items.removeIf(item -> item.equals("b")), qui fait la même chose en une seule ligne.

Lecture seule, pas de réaffectation

Autre limite subtile : affecter une valeur à la variable de boucle ne change que la copie locale, pas la collection. Cela surprend ceux qui viennent de langages où la variable de boucle est une référence vivante :

public class Main {
    public static void main(String[] args) {
        int[] nums = {1, 2, 3};

        for (int n : nums) {
            n = n * 10;   // modifie la copie, pas le tableau
        }

        System.out.println(nums[0]);   // toujours 1
    }
}

Si vous devez réécrire dans le tableau, il vous faut l'index, et cela signifie la boucle for à compteur classique : for (int i = 0; i < nums.length; i++) nums[i] = nums[i] * 10;. Pour des éléments objets, vous pouvez muter l'objet vers lequel la variable pointe (en appelant un setter, par exemple), mais vous ne pouvez pas le remplacer dans la collection.

break et continue fonctionnent toujours

Un for-each est une vraie boucle, donc break et continue se comportent exactement comme partout ailleurs : break quitte la boucle, continue saute à l'élément suivant :

public class Main {
    public static void main(String[] args) {
        String[] words = {"keep", "skip", "keep", "stop", "never"};

        for (String w : words) {
            if (w.equals("skip")) continue;   // on ignore celui-ci
            if (w.equals("stop")) break;      // on quitte entièrement
            System.out.println(w);
        }
    }
}

Cela affiche keep puis keep : ça saute "skip" et s'arrête à "stop" avant d'atteindre "never". Vous n'êtes donc pas obligé de visiter chaque élément ; vous renoncez simplement à l'index en échange d'un code plus propre.

Suivant : les tableaux

Vous avez maintenant parcouru des tableaux plusieurs fois sans vous attarder sur ce qu'ils sont vraiment : des conteneurs indexés de taille fixe avec ce champ .length. La page suivante revient au début et traite les tableaux comme il se doit : comment les déclarer, les valeurs par défaut avec lesquelles ils commencent, et en quoi leur taille fixe diffère d'un ArrayList extensible.