for, while, do while

Il arrive souvent qu'un programme doivent répéter une action un certain nombre de fois. Si par exemple je veux afficher à l'écran toutes les valeurs de 0 à 9 je vais avoir besoin d'utiliser 10 fois l'instruction IO.println() avec une nouvelle expression entre ses parenthèses à chaque fois. (Oui, de 0 à 9 il y a 10 valeurs.)

IO.println(0);
IO.println(1);
IO.println(2);
IO.println(3);
IO.println(4);
// ...
IO.println(9);

C'est long et fastidieux. Au lieu de ça, il est possible de programmer des boucles.

for

Les boucles for sont souvent utilisées quand on sait qu'on veut répéter l'action un certain nombre de fois. Il nous suffit de compter à chaque fois qu'on recommence l'action.

Sa syntaxe est la suivante :

for (/* initialisation */; /* expression booléenne */; /* mise à jour */) {
  // corps de la boucle for
}

Comme pour le if, il a une syntaxe simplifiée si son corps ne contient qu'une seule instruction :

for (/* initialisation */; /* expression booléenne */; /* mise à jour */)
  // une seule instruction

Les parenthèses du for ont une grande importance car c'est ici qu'on va déclarer combien de fois le corps va s'exécuter. On sépare les différentes parties par un point-virgule ;.

Dans 99% des situations, une boucle for va avoir une initialisation d'une variable de type int qui vaudra 0, qui devra atteindre une valeur strictement positive via l'expression booléenne donnée en 2ème partie et qui sera incrémentée grâce à la 3ème partie de mise à jour :

for (int i = 0; i < 10; i++) {
  IO.println(i); // cette action va se répéter 10 fois
}

Ce programme est strictement identique au fait de copier/coller 10 fois comme dans l'introduction de cette partie

Son exécution est assez simple à comprendre. Si je garde le même exemple voilà ce que ça donne :

j'initialise une variable i à 0
SI la condition i < 10 est respectée je passe à l'étape 3, sinon je passe à l'étape 5
ALORS j'exécute le corps de la boucle
à la fin du corps de la boucle, je mets à jour i et je reviens à l'étape 2
je quitte la boucle for

Arrivera un moment où i sera égal à 10 et dans ce cas, la condition i < 10 ne sera plus respectée. On quittera alors la boucle for.

while

Il existe un autre type de boucle, plus généraliste. La boucle while.

while (/* expression booléenne */) {
  // corps de la boucle while
}

Comme tous les blocs de contrôles, on peut le simplifier en

while (/* expression booléenne */)
  // une seule instruction

Celle ci est à exécuter tant que la condition est vérifiée. On peut s'en servir d'une façon similaire à la boucle for rencontrée juste avant :

int i = 0;

while (i < 10) {
  IO.println(i); // cette action va se répéter 10 fois
  i++; // ne surtout pas l'oublier !
}

Ce code a exactement le même comportement que la boucle for au dessus.

Son exécution est légèrement différente du for. Si je garde le même exemple voilà ce que ça donne :

j'initialise une variable i à 0
SI la condition i < 10 est respectée je passe à l'étape 3, sinon je passe à l'étape 5
ALORS j'exécute le corps de la boucle et je reviens à l'étape 2
je quitte la boucle for

Il faut se méfier de la boucle while car il est possible d'oublier de mettre à jour notre variable i dans son corps, ce qui résulterait dans une boucle infinie !

do while

Les boucles do while sont similaires aux boucles while à une différence : avant de vérifier si la condition est respectée, une première exécution de son corps est faite.

int i = 0;

do {
  IO.println(i); // cette action va se répéter 10 fois
  i++;
} while(i < 10);

Son exécution est assez différente des deux autres. Si je garde le même exemple voilà ce que ça donne :

j'initialise une variable i à 0
j'exécute le corps de la boucle
SI la condition i < 10 est respectée je passe à l'étape 2, sinon je passe à l'étape 4
je quitte la boucle for

Boucles infinies

Les boucles infinies font parties des erreurs de développement les plus courantes, surtout quand on débute. Si ça vous arrive, il faudra arrêter vous même le programme.
Si vous utilisez IntelliJ, utilisez le bouton stop soit dans la console, soit en haut de l'affichage.

Pasted image 20250325120446.png

Pasted image 20250325120808.png

Vous pouvez d'ailleurs remarquer que ma condition i < 10 est surlignée dans mon IDE. Si je passe ma souris dessus je peux vois que c'est parce qu'il me prévient que je vais faire une bêtise si j'oublie de la mettre à jour. Pratique ! Mais ça ne marche pas à tous les coups. Parfois si votre programme est trop complexe, même votre IDE ne pourra pas beaucoup vous aider donc ne vous faites pas avoir !
D'ailleurs on notera qu'il me propose de simplifier ma condition par un simple true. Non merci, ce serait délibérément me tirer une balle dans le pied. (Si vous ne comprenez pas pourquoi, essayez et jetez un oeil aux étapes de l'exécution d'une boucle pendant que votre PC brûle des calories).

Remarque

Je vous suggère de privilégier les boucles for aux boucles while car elles imposent de ne pas oublier l'étape de mise à jour essentielle pour ne pas tomber dans la boucle infinie. Mais il y a des cas où la boucle while est plus pratique si on ne sait pas combien de fois elle va s'exécuter et que la condition d'arrêt et la mise à jour nécessitent des calculs plus importants.
Imaginons que je code un jeu et je veux que le joueur joue jusqu'à ce qu'il perde. Tant qu'il n'a pas perdu, alors il peut jouer un nouveau coup.

boolean perdu = false;

while (!perdu) {
  perdu = jouerUnCoup();
}

Ici, jouerUnCoup() sort un peu de nulle part, mais bientôt vous pourrez créer vos propres méthodes. Tiens, d'ailleurs, pourquoi pas maintenant ?
Let's go !