Boucle for en Java : syntaxe, exemples et le for-each amélioré

La classique boucle for en trois parties

Une boucle for répète un bloc un nombre contrôlé de fois. La forme de Java regroupe trois choses entre les parenthèses, séparées par des points-virgules :

public class Main {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            System.out.println("i = " + i);
        }
    }
}

Les trois parties s'exécutent selon un rythme fixe :

1. Initialisation (int i = 0) - s'exécute une fois, avant tout le reste.
2. Condition (i < 5) - vérifiée avant chaque passage ; la boucle s'arrête quand elle est fausse.
3. Mise à jour (i++) - s'exécute après chaque passage, avant que la condition ne soit revérifiée.

Donc ceci affiche de i = 0 à i = 4. Le compteur i a une portée limitée à la boucle - il n'existe pas après l'accolade de fermeture.

Compter vers le haut, vers le bas et par pas

Les trois parties te donnent un contrôle total sur le compteur :

public class Main {
    public static void main(String[] args) {
        for (int i = 10; i > 0; i--) {       // compter à rebours
            System.out.print(i + " ");
        }
        System.out.println();

        for (int i = 0; i <= 20; i += 5) {   // avancer par pas de 5
            System.out.print(i + " ");
        }
    }
}

i-- décrémente, i += 5 saute par pas de cinq. La condition décide de l'arrêt selon la direction : utilise > quand tu comptes à rebours, < ou <= quand tu comptes vers le haut.

Parcourir un tableau

Une boucle comptée se marie naturellement avec un tableau, en utilisant .length comme borne et i comme indice :

public class Main {
    public static void main(String[] args) {
        String[] colors = {"red", "green", "blue"};

        for (int i = 0; i < colors.length; i++) {
            System.out.println(i + ": " + colors[i]);
        }
    }
}

Remarque que colors.length est un champ sans parenthèses - les tableaux sont spéciaux sur ce point. Une List utilise en revanche list.size(). La condition i < colors.length est correcte : les indices vont de 0 à length - 1, donc utiliser < (et non <=) évite une erreur de dépassement de limites.

La boucle for-each améliorée

Quand tu n'as besoin que de chaque élément et jamais de l'indice, le for amélioré est plus propre et plus difficile à rater - aucun compteur à décaler d'une unité :

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> colors = List.of("red", "green", "blue");

        for (String color : colors) {
            System.out.println(color.toUpperCase());
        }
    }
}

Lis for (String color : colors) comme « pour chaque color dans colors ». Cela fonctionne sur les tableaux et tout ce qui est itérable. Le compromis : tu n'as pas d'indice et tu ne peux pas ajouter ni retirer d'éléments de la collection pendant que tu la parcours (cela lève ConcurrentModificationException). Recours à la boucle comptée quand tu as besoin de l'un ou l'autre.

Boucles imbriquées

Une boucle dans une boucle - utile pour les grilles, les tableaux et les appariements. La boucle interne s'exécute entièrement à chaque passage de la boucle externe :

public class Main {
    public static void main(String[] args) {
        for (int row = 1; row <= 3; row++) {
            for (int col = 1; col <= 3; col++) {
                System.out.print(row * col + "\t");
            }
            System.out.println();
        }
    }
}

Ceci affiche une grille de multiplication 3x3. Donne aux compteurs des noms parlants (row, col) plutôt que i, j une fois que l'imbrication devient profonde - cela t'évite de confondre lequel est lequel.

break et continue

break sort de la boucle immédiatement. continue saute le reste du passage en cours et passe à l'étape de mise à jour :

public class Main {
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            if (i % 2 == 0) continue;   // sauter les nombres pairs
            if (i > 7) break;           // s'arrêter une fois passé 7
            System.out.println(i);
        }
    }
}

Ceci affiche 1 3 5 7. continue saute les pairs ; break met fin à la boucle dès que i dépasserait 7. Dans les boucles imbriquées, les deux n'affectent que la boucle la plus interne, sauf si tu utilises un break étiqueté.

Attention aux boucles infinies

Si la condition ne devient jamais fausse, la boucle s'exécute indéfiniment. La cause habituelle est d'oublier la mise à jour ou de déplacer le compteur dans le mauvais sens :

for (int i = 0; i < 5; i--) {   // i ne fait que diminuer -> n'atteint jamais 5
    System.out.println(i);
}

Une boucle infinie intentionnelle omet les trois parties -for (;;) { ... }- et compte sur un break à l'intérieur pour s'arrêter. Utilise-la avec parcimonie ; un while (true) se lit en général plus clairement.

Suivant : les boucles while

La boucle for brille quand tu connais le compteur d'avance. Quand tu veux boucler jusqu'à ce qu'une condition change - et que tu n'as pas de compteur net -, la boucle while convient mieux. C'est la page suivante.