Boucle For en Java

On dit que le meilleur programmeur est un programmeur paresseux. Au lieu d’effectuer plusieurs fois le même type d’actions, il proposera un algorithme qui fera le travail à sa place. Et il le fera bien pour qu'il n'y ait pas besoin de le refaire. Afin d’éviter d’écrire encore et encore le même code, des boucles ont été inventées. Imaginons que nous ayons besoin d'afficher sur la console des nombres de 0 à 99. Code sans boucle :

System.out.println(0);
System.out.println(1);
System.out.println(2);
System.out.println(3);
System.out.println(4);
System.out.println(5);
// And so on

Ce code prendra 100 lignes ! Tant. Et voici à quoi cela ressemblerait avec une boucle :

for(int i = 0; i < 100; i++) {
   System.out.println(i);
}

Juste 3 lignes !

Que sont les boucles for ?

Une boucle for est une structure de contrôle du code du programme qui brise la linéarité de l'exécution de l'algorithme et vous permet d'exécuter le code spécifié plusieurs fois. Par exemple, vous devez prendre 30 gouttes de médicament. L'algorithme ressemblera à ceci :

1. Préparez un verre.
2. Ouvrez le couvercle.
3. Obtenez 1 goutte.
4. Obtenez 2 gouttes.
...
32. Obtenez 30 gouttes.
33. Fermez le médicament.
34. Prenez la portion reçue.

Cet algorithme peut être expliqué beaucoup plus rapidement :

1. Préparez un verre.
2. Ouvrez le bouchon anti-goutte.
3. Obtenez 30 gouttes.
4. Fermez le médicament.
5. Prenez la portion reçue.

Nous utilisons la boucle for presque tous les jours dans nos conversations avec d'autres personnes : "...20 pas dans la rue...", "...faites 10 répétitions et 5 autres à 2 fois plus lentement...", ".. .faites 5 achats dans différentes catégories et recevez un prix… » Je pourrais continuer longtemps, mais le sens est clair. En Java, la boucle for est essentielle pour garder votre code court et concis.

Comment fonctionne la boucle for

Une boucle for s'utilise comme ceci :

for(<начальная точка>; <condition выхода>; <операторы счетчика>) {
	// Loop body
}
Пример перебора цифр от 0 до 5 и вывод каждой в консоль:
for(int i = 0; i < 5; i++) {
   System.out.println(i);
}

Conclusion:

0
1
2
3
4

Si nous traduisons cette entrée en langage humain, nous obtenons ce qui suit : « Créez une variable i avec une valeur initiale de 0, jusqu'à ce qu'elle atteigne 5, ajoutez-y 1 et à chaque étape écrivez la valeur de i dans la console . » La boucle for en Java repose sur trois étapes, qui peuvent être représentées par le schéma suivant : La condition de sortie de la boucle est une expression booléenne. Si c'est faux, la boucle se terminera. Dans l'exemple ci-dessus, la variable iest incrémentée de 1. Si sa valeur est inférieure à 5, la boucle continue. Mais dès qu’il idevient supérieur ou égal à 5, le cycle s’arrête. L'opérateur compteur est une expression qui effectue une conversion sur une variable compteur. Dans l'exemple ci-dessus, la variable ia été augmentée de 1. Autrement dit, la boucle sera exécutée exactement 5 fois. Si l'opérateur compteur ajoute 2 à la variable i, le résultat sera différent :

for(int i = 0; i < 5; i = i + 2) {
   System.out.println(i);
}

Conclusion:

0
2
4

Vous pouvez aussi multiplier une variable, diviser, élever à une puissance, en général, faire ce que vous voulez. L'essentiel est que la transformation aboutisse à un nombre. Le corps de la boucle est tout code pouvant être exécuté. Dans l'exemple ci-dessus, le corps de la boucle envoyait la valeur de la variable i à la console, mais le contenu de ce corps est limité par la tâche et l'imagination. Résumant l'ensemble du schéma, le principe de cette boucle for est le suivant : le code qui se trouve dans le corps de la boucle sera exécuté autant de fois que le nombre de conversions que l'opérateur compteur effectuera avant que la condition de sortie de la boucle ne soit atteinte. . Si vous définissez la condition de sortie de boucle commetrue :

for(int i = 0; true; i++) {
   if(i % 1000000 == 0) System.out.println(i);
}
System.out.println("Loop ended");

Ensuite, le code après la boucle sera marqué d'une erreur unreachable statement, puisqu'il ne sera jamais exécuté. Un défi d'ingéniosité : suite à l'exécution du code ci-dessous, «Loop ended » sera-t-il affiché sur la console ou la boucle s'exécutera-t-elle sans fin ?

for(int i = 0; i > -1; i++) {
   if(i % 1000000 == 0) System.out.println(i);
}
System.out.println("Loop ended");

Réponse : il y en aura. La variable i atteindra tôt ou tard sa valeur maximale et une nouvelle augmentation la transformera en une valeur négative maximale, ce qui permettra de satisfaire la condition de sortie (i < = -1).

boucle forEach

Lorsque vous travaillez avec des boucles, vous devez parfois parcourir des tableaux ou des collections. En règle générale, vous pouvez parcourir un tableau à l'aide d'une boucle for :

public void printAllElements(String[] stringArray) {
   for(int i = 0; i < stringArray.length; i++) {
       System.out.println(stringArray[i]);
   }
}

Et c'est vrai. Cependant, pour parcourir tous les éléments du tableau un par un, ils ont proposé la construction forEach. Sa signature est la suivante :

for(<Тип element> <Name переменной, куда будет записан очередной элемент> : <Название массива>) {
	// Loop body
}

Vous pouvez parcourir un tableau de chaînes et imprimer chacune d'entre elles sur la console de la manière suivante :

public void printAllElements(String[] stringArray) {
   for(String s : stringArray) {
       System.out.println(s);
   }
}

Également court et concis. Surtout, il n'y a pas besoin de penser au compteur et aux conditions de sortie, tout est déjà fait pour nous.

Comment les boucles for sont utilisées

Examinons maintenant quelques exemples d'utilisation de la boucle for en Java pour résoudre divers problèmes.

Cycle inversé (du plus grand au plus petit)

for(int i = 5; i > 0; i--) {
   System.out.println(i);
}

Conclusion:

5
4
3
2
1

Plusieurs variables et incrémentation du compteur dans le corps de la boucle

Vous pouvez utiliser plusieurs variables dans une boucle for, par exemple elles peuvent être converties en une instruction counter :

int a = 0;
for(int i = 5; i > 0; i--, a++) {
   System.out.print("Step: " + a + " Meaning: ");
   System.out.println(i);
}

Conclusion:

Шаг: 0 Значение: 5
Шаг: 1 Значение: 4
Шаг: 2 Значение: 3
Шаг: 3 Значение: 2
Шаг: 4 Значение: 1

Ou déclarez deux variables et faites une boucle jusqu'à ce qu'elles soient égales l'une à l'autre :

for(int i = 5, j = 11; i != j; i++, j--) {
   System.out.println("i: " + i + " j: " + j);
}

Conclusion:

i: 5 j: 11
i: 6 j: 10
i: 7 j: 9

Il est peu probable que cette action ait une quelconque valeur, mais il est utile de connaître cette possibilité. Vous pouvez également créer des boucles internes dans une boucle for. Dans ce cas, le nombre d'étapes de boucle sera multiplié :

for(int i = 0; i < 5; i++) {
   System.out.print(i + " | ");
   for(int j = 0; j < 5; j++) {
       System.out.print(j + " ");
   }
   System.out.print('\n');
}

Conclusion:

0 | 0 1 2 3 4 
1 | 0 1 2 3 4 
2 | 0 1 2 3 4 
3 | 0 1 2 3 4 
4 | 0 1 2 3 4

Dans une boucle compteur, jil est possible d'accéder au compteur de la boucle externe. Cela fait des boucles imbriquées un moyen idéal pour parcourir des tableaux bidimensionnels, tridimensionnels et autres :

int[][] array = { {0, 1, 2, 3, 4 },
                       {1, 2, 3, 4, 5},
                       {2, 3, 4, 5, 6},
                       {3, 4, 5, 6, 7}};

for(int i = 0; i < array.length; i++) {
   for(int j = 0; j < array[i].length; j++) {
       System.out.print(array[i][j] + " ");
   }
   System.out.print('\n');
}

Conclusion:

0 1 2 3 4 
1 2 3 4 5 
2 3 4 5 6 
3 4 5 6 7 

Achèvement anticipé du cycle

Si vous devez interrompre une boucle pendant le traitement d'une boucle, utilisez l'opérateur break, qui arrête le corps actuel de la boucle. Toutes les itérations suivantes sont également ignorées :

public void getFirstPosition(String[] stringArray, String element) {
   for (int i = 0; i < stringArray.length; i++) {
       if(stringArray[i].equals(element)) {
           System.out.println(i);
           break;
       }
   }
}

La méthode imprimera la position du premier élément recherché dans le tableau :

String[] array = {"one", "two", "three", "Jeronimo"};
getFirstPosition(array, "two");

Conclusion:

1

Cycle sans fin

Une autre façon de créer une boucle for infinie consiste à laisser la zone de déclaration du compteur, la condition de sortie et l'instruction du compteur vides :

for (;;) {
}

Mais gardez à l’esprit que dans la plupart des cas, une boucle infinie est la preuve d’une erreur logique. Une telle boucle doit avoir une condition de sortie.