Boucle while en Java : syntaxe, do-while et pièges courants

Quand vous n'avez pas de compteur

La boucle for est construite autour d'un compteur que vous mettez en place d'avance. Mais bien des boucles n'ont pas de comptage net : continuer à lire des lignes jusqu'à la fin du fichier, continuer à demander un mot de passe jusqu'à ce qu'il soit correct, continuer à diviser un nombre par deux jusqu'à ce qu'il atteigne 1. Pour ces cas, la boucle while s'impose naturellement : elle répète simplement tant qu'une condition reste vraie.

Une boucle while teste sa condition avant chaque passage, y compris le tout premier. Si la condition est fausse dès le départ, le corps ne s'exécute jamais.

public class Main {
    public static void main(String[] args) {
        int count = 3;

        while (count > 0) {
            System.out.println("Liftoff in " + count);
            count--;
        }

        System.out.println("Go!");
    }
}

La condition count > 0 est testée en premier ; si elle est vraie, le corps s'exécute ; puis on revient au début et on teste de nouveau. La ligne count-- est ce qui finit par rendre la condition fausse ; retirez-la et la boucle tourne à l'infini.

L'anatomie d'une boucle while

Comparez-la à la boucle for en trois parties que vous connaissez déjà. Une boucle while sépare ces trois rôles : vous faites l'initialisation avant la boucle, la condition va entre les parenthèses et la mise à jour vit à l'intérieur du corps.

int i = 0;              // initialisation - avant la boucle
while (i < 5) {         // condition - testée à chaque passage
    System.out.println(i);
    i++;                // mise à jour - vous devez y penser vous-même
}

Cette dernière partie est le piège. Dans une boucle for, la mise à jour est juste à côté de la condition, donc difficile à oublier. Dans une boucle while, ce n'est qu'une instruction de plus dans le corps : le bug le plus courant est de l'omettre et de bloquer le programme.

do-while : exécuter le corps au moins une fois

Parfois, vous avez besoin que le corps s'exécute une fois avant de pouvoir même décider de recommencer. La boucle do-while teste sa condition à la fin, donc le corps s'exécute toujours au moins une fois :

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int number;

        do {
            System.out.print("Enter a positive number: ");
            number = in.nextInt();
        } while (number <= 0);

        System.out.println("Thanks! You entered " + number);
    }
}

Vous devez demander et lire au moins une fois avant de savoir si la saisie est valide, ce qui est exactement ce que vous offre do-while. Notez le point-virgule après while (...) : il est obligatoire, et l'oublier est une erreur de compilation fréquente.

La différence avec un while simple apparaît clairement quand la condition est fausse dès le départ :

public class Main {
    public static void main(String[] args) {
        int x = 10;

        // while : condition fausse d'emblée -> le corps ne s'exécute jamais
        while (x < 5) {
            System.out.println("while body");
        }

        // do-while : s'exécute une fois, PUIS teste -> le corps s'exécute exactement une fois
        do {
            System.out.println("do-while body");
        } while (x < 5);
    }
}

Seul do-while body s'affiche. La boucle while saute entièrement son corps parce que x < 5 était faux avant le premier test.

Boucler jusqu'à une valeur sentinelle

Un usage classique de while est de lire jusqu'à une valeur d'arrêt spéciale : une sentinelle. Il n'y a pas de compteur ici ; vous continuez simplement jusqu'à ce que les données vous disent de vous arrêter :

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int sum = 0;

        System.out.println("Enter numbers to add (0 to finish):");
        int value = in.nextInt();

        while (value != 0) {
            sum += value;
            value = in.nextInt();
        }

        System.out.println("Total: " + sum);
    }
}

Le schéma est lire une fois avant la boucle, puis relire à la fin de chaque passage. Ainsi la condition teste toujours une saisie fraîche. Si vous oubliez la seconde lecture à l'intérieur du corps, value ne change jamais et vous avez une boucle infinie.

break et continue dans les boucles while

break et continue fonctionnent ici comme dans une boucle for. break quitte la boucle immédiatement ; continue saute directement au test de la condition, en ignorant le reste du passage en cours :

public class Main {
    public static void main(String[] args) {
        int n = 0;

        while (true) {              // « boucle infinie » volontaire
            n++;
            if (n % 2 == 0) continue;   // ignore les nombres pairs
            if (n > 9) break;           // arrête une fois passé 9
            System.out.println(n);
        }
    }
}

Ceci affiche 1 3 5 7 9. Le while (true) ne s'arrête volontairement jamais de lui-même : le break est la seule sortie. Attention au continue dans une boucle while : comme la mise à jour fait partie du corps, revenir au début avec continue avant d'avoir fait avancer votre compteur est une façon silencieuse de bloquer la boucle. Dans l'exemple ci-dessus, n++ s'exécute en premier, donc c'est sûr.

Attention aux boucles infinies

La condition doit finir par devenir fausse, et cela dépend entièrement d'un changement à l'intérieur du corps. Les deux coupables habituels sont d'oublier la mise à jour et de mettre à jour de la mauvaise manière :

int i = 0;
while (i < 5) {
    System.out.println(i);   // i ne change jamais -> tourne à l'infini
}

int i = 0;
while (i != 10) {
    i += 3;   // 0, 3, 6, 9, 12... dépasse 10 sans s'arrêter -> tourne à l'infini
}

La première se bloque parce que i n'est jamais mis à jour. La seconde se bloque parce que le compteur enjambe la valeur exacte que la condition recherche ; préférez < ou <= à != quand le pas risque de ne pas tomber pile. Un while (true) est acceptable s'il possède un break garanti ; un while (true) accidentel n'est qu'un bug.

Suite : la boucle for-each

Une boucle while est le bon outil quand vous bouclez jusqu'au changement d'une condition et qu'il n'y a pas de comptage net. Mais quand vous voulez simplement parcourir chaque élément d'un tableau ou d'une liste (pas d'indice, pas de condition à gérer), il existe quelque chose d'encore plus net : la boucle for-each améliorée. C'est la page suivante.