Avec la while loop dans Java, également appelée « boucle while » en français, vous pouvez exécuter des déclarations jusqu’à ce qu’une condition de terminaison soit atteinte. Cette forme de boucle peut également être combinée et imbriquée.

Hébergement Web
Hébergement Web flexible, performant et sûr
  • Certificat SSL et protection DDoS
  • Sauvegarde et restauration des données
  • Assistance 24/7 et conseiller personnel

La while loop dans Java : de quoi s’agit-il ?

La boucle while fournit aux utilisateurs de Java la capacité d’exécuter n’importe quel nombre de déclarations, aussi longtemps qu’une condition définie au préalable reste vraie. Une variable count n’est pas nécessaire, la condition de terminaison peut dès lors être définie séparément.

La condition de terminaison fonctionne d’après un modèle booléen. Cela signifie que la while loop dans Java exécute les déclarations insérées aussi longtemps que la condition spécifiée dans l’en-tête est vraie. Si la condition de terminaison devient « fausse » pour la première fois, la boucle prend fin. Compte tenu du fait que la condition de terminaison est déjà définie dans la tête de la boucle while dans Java, on dit de cette dernière qu’elle est « contrôlée par la tête ».

Comment la boucle while est-elle construite dans Java ?

En général, la structure d’une boucle while change assez peu dans Java. Tandis que la syntaxe reste identique, seules les déclarations et la condition de terminaison varient. Pour commencer, le terme « while » introduit la boucle, puis la condition de terminaison suit entre parenthèses, et, enfin, viennent une ou plusieurs déclarations entre accolades. Voici comment se présente une boucle while en code-source Java :

while ( termination condition) {
Statement
}

Le travail se déroule toujours dans cet ordre :

  1. Le programme vérifie la condition
  2. Si cette dernière est atteinte, l’application Java exécute la déclaration.
  3. Ensuite, le programme repart au début.
  4. Une fois encore, la condition est vérifiée.
  5. Si celle-ci est désormais « false » (« fausse »), le programme quitte la boucle while dans Java et continue à progresser au fil du code.

Exemple d’une boucle simple

Prenons un exemple simple de loop while dans Java : un compteur qui compte jusqu’à une certaine valeur. Il fait très exactement cela jusqu’à ce que la valeur spécifiée (la condition de terminaison) soit atteinte. En version rédigée, cela se présente comme ceci :

int i = 0;
while ( i <= 5 ) {
System.out.println ( “The current value is at: “ + i );
i++;
}

La variable « i » commence à zéro dans cette configuration. Elle devrait à présent augmenter de 1 en 1 jusqu’à ce qu’elle atteigne la valeur « 5 ». Ceci est réalisé à l’aide de l’opérateur Java ++. Lors du prochain tour, au moment où la valeur devrait atteindre « 6 », le programme prendra fin et la boucle-while dans Java sera interrompue. La commande Java System.out.println indique donc la série de nombres 1, 2, 3, 4, 5.

Éviter les boucles sans fin

Même si la loop while dans Java est simple dans sa structure, elle présente quelques sources d’erreur potentielles qui peuvent causer l’échec de cette boucle. Si une information importante est absente ou que la condition de terminaison ne peut être atteinte, vous obtiendrez une boucle infinie. Ceci met en échec le programme, ou y met fin au bout d’un moment. Cela se produit, à titre d’exemple, si la vérification de la condition de terminaison affiche toujours « true » ou si la valeur ciblée ne peut pas être atteinte.

La différence entre loop while et loop do-while dans Java

Outre la while-loop dans Java, il existe également la do-while-loop (« boucle do-while » en français). Cette dernière a non seulement un nom similaire, mais fonctionne également de manière presque identique à la boucle while. La différence majeure est qu’étant contrôlée par la tête, la boucle while vérifie la condition de terminaison en avance, tandis que la boucle do-while, contrôlée par le pied, attend jusqu’à ce que les déclarations aient été exécutées au moins une fois.

On peut observer ceci dans la structure ci-dessous :

int i = 0;
do {
System.out.println ( “The current value is at: “ + i );
i++;
}
while ( i <= 5 );

Ici, le code est exécuté au moins une fois, avant que la condition soit vérifiée par la suite.

Imbriquer des boucles while dans Java

Vous disposez également de l’option d’imbriquer plusieurs boucles while dans Java. Si on prend maintenant l’exemple de deux compteurs, cela se présentera comme ceci :

int i = 0;
while ( i 
System.out.println ( “The current value is: “ + i );
i++;
int Intermediate step = 0;
while ( intermediate step 
System.out.println ( “The current intermediate value is at: “ + intermediate step );
IntermediateStep++;
}
}

Ainsi, en premier lieu, la boucle while extérieure est vérifiée par le programme Java. Si cette dernière est « vraie », le programme bascule dans la boucle intérieure et la vérifie également. À ce moment-là, la boucle intérieure est vérifiée jusqu’à ce que sa condition de terminaison soit « fausse ». Puis le programme bascule à nouveau sur la boucle extérieure.

La différence entre for et while dans Java

Outre la boucle while présentée ici et la loop do-while de Java également évoquée, la boucle for dans Java existe également. Au premier abord, celle-ci ressemble à la loop while de Java, étant donné qu’elle répète également un code jusqu’à ce que la condition de terminaison devienne « false ». À la différence de la boucle while, néanmoins, la boucle for a également une variable run qui est initialisée avant la condition de terminaison.

Cet article vous a-t-il été utile ?
Aller au menu principal