Les instructions de programme structurées séquentiellement ne peuvent être exécutées qu'une seule fois. Si vous souhaitez effectuer plusieurs fois la même opération, vous devez utiliser une structure en boucle.
Il existe trois structures de boucles principales en Java :
boucle while
faire… en boucle
pour la boucle
Dans Java5, une boucle for améliorée a été introduite principalement pour les tableaux.
while est la boucle la plus basique, sa structure est :
while(expression booléenne) {
//Contenu de la boucle}Tant que l'expression booléenne est vraie, le corps de la boucle continuera à s'exécuter.
Test de classe publique {
public static void main(String args[]) {
entier x = 10 ;
tandis que( x < 20 ) {
System.out.print("valeur de x : " + x );
x++;
System.out.print("n");
}
}
}Les résultats de compilation et d'exécution de l'exemple ci-dessus sont les suivants :
valeur de x : 10
valeur de x : 11
valeur de x : 12
valeur de x : 13
valeur de x : 14
valeur de x : 15
valeur de x : 16
valeur de x : 17
valeur de x : 18
valeur de x : 19Pour l'instruction while, si la condition n'est pas remplie, la boucle ne peut pas être entrée. Mais parfois, nous devons l’exécuter au moins une fois même si les conditions ne sont pas remplies.
La boucle do...while est similaire à la boucle while, sauf que la boucle do...while sera exécutée au moins une fois.
faire {
//Instruction de code} while (expression booléenne);Remarque : L'expression booléenne se trouve après le corps de la boucle, le bloc d'instructions a donc été exécuté avant que l'expression booléenne ne soit détectée. Si l’expression booléenne est évaluée à vrai, le bloc d’instructions est exécuté jusqu’à ce que l’expression booléenne soit évaluée à faux.
Test de classe publique {
public static void main(String args[]){
entier x = 10 ;
faire{
System.out.print("valeur de x : " + x );
x++;
System.out.print("n");
}pendant( x < 20 );Les résultats de compilation et d'exécution de l'exemple ci-dessus sont les suivants :
valeur de x : 10
valeur de x : 11
valeur de x : 12
valeur de x : 13
valeur de x : 14
valeur de x : 15
valeur de x : 16
valeur de x : 17
valeur de x : 18
valeur de x : 19Bien que toutes les structures de boucle puissent être exprimées avec while ou do... while, Java fournit une autre instruction - la boucle for, qui simplifie certaines structures de boucle.
Le nombre de fois que la boucle for est exécutée est déterminé avant l'exécution. Le format de syntaxe est le suivant :
pour (initialisation ; expression booléenne ; mise à jour) {
//instruction de code}Voici quelques remarques sur la boucle for :
L'étape d'initialisation est effectuée en premier. Un type peut être déclaré, mais une ou plusieurs variables de contrôle de boucle peuvent être initialisées, ou il peut s'agir d'une instruction vide.
Ensuite, testez la valeur de l'expression booléenne. Si c'est vrai, le corps de la boucle est exécuté. Si c'est faux, la boucle se termine et l'exécution des instructions suivant le corps de la boucle commence.
Après avoir exécuté la boucle une fois, mettez à jour les variables de contrôle de boucle.
Vérifiez à nouveau l'expression booléenne. Effectuez le processus ci-dessus en boucle.
Test de classe publique {
public static void main(String args[]) {
pour(int x = 10; x < 20; x = x+1) {
System.out.print("valeur de x : " + x );
System.out.print("n");
}
}
}Les résultats de compilation et d'exécution de l'exemple ci-dessus sont les suivants :
valeur de x : 10
valeur de x : 11
valeur de x : 12
valeur de x : 13
valeur de x : 14
valeur de x : 15
valeur de x : 16
valeur de x : 17
valeur de x : 18
valeur de x : 19Java5 a introduit une boucle for améliorée principalement pour les tableaux.
Le format de syntaxe de boucle for amélioré Java est le suivant :
pour (instruction de déclaration : expression)
{
//phrase de code}Instruction de déclaration : déclarez une nouvelle variable locale. Le type de la variable doit correspondre au type de l'élément du tableau. Sa portée est limitée au bloc d'instructions de boucle et sa valeur est égale à la valeur de l'élément du tableau à ce moment-là.
Expression : L'expression est le nom du tableau auquel accéder ou une méthode qui renvoie un tableau.
Test de classe publique {
public static void main(String args[]){
int [] nombres = {10, 20, 30, 40, 50} ;
pour(int x : nombres ){
System.out.print(x);
System.out.print(",");
}
System.out.print("n");
Chaîne [] noms ={"James", "Larry", "Tom", "Lacy"};
for( Nom de la chaîne : noms ) {
System.out.print( nom );
System.out.print(",");
}
}
}Les résultats de compilation et d'exécution de l'exemple ci-dessus sont les suivants :
10,20,30,40,50,
James, Larry, Tom, Lacy,break est principalement utilisé dans les instructions de boucle ou les instructions switch pour sortir de l'ensemble du bloc d'instructions.
break sort de la boucle la plus interne et continue d'exécuter les instructions situées en dessous de la boucle.
L'utilisation de break est très simple, c'est une instruction dans la structure de boucle :
casser; Test de classe publique {
public static void main(String args[]) {
int [] nombres = {10, 20, 30, 40, 50} ;
pour(int x : nombres ) {
si( x == 30 ) {
casser;
}
System.out.print(x);
System.out.print("n");
}
}
}Les résultats de compilation et d'exécution de l'exemple ci-dessus sont les suivants :
10
20continue s'applique à toute structure de contrôle de boucle. La fonction est de permettre au programme de passer immédiatement à l'itération suivante de la boucle.
Dans la boucle for, l'instruction continue fait passer le programme immédiatement à l'instruction update.
Dans une boucle while ou do... while, le programme passe immédiatement à l'instruction de jugement de l'expression booléenne.
continue est une simple instruction dans le corps de la boucle :
continuer; Test de classe publique {
public static void main(String args[]) {
int [] nombres = {10, 20, 30, 40, 50} ;
pour(int x : nombres ) {
si( x == 30 ) {
continuer;
}
System.out.print(x);
System.out.print("n");
}
}
}Les résultats de compilation et d'exécution de l'exemple ci-dessus sont les suivants :
10
20
40
50