La boucle while en Java

La boucle while est le moyen le plus simple de répéter un bloc de code en Java. Tant que sa condition est true, le corps s'exécute à nouveau. Quand la condition devient false, la boucle se termine et l'exécution reprend après la boucle.

Syntaxe

while (condition) {
  // body — runs while condition is true
}

Un exemple minimal — compter de 1 à 5 :

int i = 1;
while (i <= 5) {
  System.out.println(i);
  i++;
}

La condition i <= 5 est vérifiée avant chaque itération. Quand i devient 6, la condition est fausse et la boucle se termine.

Les deux éléments à toujours retenir

Toute boucle while a besoin de deux choses pour se terminer :

1. Une condition pouvant devenir fausse. Un true constant s'exécute indéfiniment.
2. Quelque chose à l'intérieur du corps qui modifie la condition. Oubliez de mettre à jour i et la boucle devient infinie.

Une erreur courante pour les débutants :

int i = 1;
while (i <= 5) {
  System.out.println(i);
  // forgot i++ — loop runs forever
}

Si votre programme se fige, commencez par vérifier ici. Appuyer sur Ctrl+C dans le terminal arrête un programme incontrôlable.

L'autre erreur classique de décalage par un est l'opérateur de comparaison. while (i <= 5) avec i démarrant à 1 s'exécute cinq fois ; while (i < 5) ne s'exécute que quatre fois. Décidez si la valeur limite doit être incluse avant d'écrire la condition.

La condition est vérifiée en premier

Si la condition est fausse au départ, le corps ne s'exécute jamais — pas même une seule fois :

int i = 10;
while (i < 5) {
  System.out.println(i);   // never executes
}

C'est la différence essentielle avec la boucle do/while, qui exécute toujours le corps au moins une fois.

Quand while est le bon choix

Une boucle for est préférable quand vous connaissez le nombre d'itérations à l'avance (for (int i = 0; i < 10; i++)). Une boucle while est préférable quand la condition d'arrêt n'est pas liée à un compteur — elle est liée à un changement d'état, et vous ne savez pas à l'avance combien d'itérations seront nécessaires.

Lire jusqu'à la fin de l'entrée :

import java.util.Scanner;

Scanner s = new Scanner(System.in);
while (s.hasNextLine()) {
  String line = s.nextLine();
  System.out.println("got: " + line);
}

Réessayer jusqu'au succès :

boolean connected = false;
int attempts = 0;
while (!connected && attempts < 5) {
  connected = tryConnect();
  attempts++;
}

Traiter une file d'attente :

while (!queue.isEmpty()) {
  Task t = queue.poll();
  t.run();
}

Boucles infinies intentionnelles

Parfois, vous souhaitez que la boucle s'exécute indéfiniment — généralement dans des boucles d'événements, des serveurs ou des simulations — et vous en sortez avec un break :

while (true) {
  String input = readCommand();
  if (input.equals("quit")) {
    break;
  }
  handle(input);
}

while (true) est plus idiomatique que while (1 == 1) ou d'autres astuces.

Utiliser break et continue

À l'intérieur de toute boucle, vous pouvez utiliser :

• break — quitter la boucle entièrement
• continue — ignorer le reste de l'itération en cours et revérifier la condition

Les deux sont traités en détail dans break et continue.

Un exemple complet

Prochaine étape

Un proche cousin de while est la boucle do-while, qui exécute toujours le corps au moins une fois.

Pratique