pour la boucle

1. Comparer les boucles : forvswhile

Une whileboucle peut être utilisée partout où une instruction ou un groupe d'instructions doit être exécuté plusieurs fois. Mais parmi tous les scénarios possibles, un mérite d'être souligné.

Nous parlons de la situation où le programmeur (le créateur du programme) sait à l'avance combien de fois la boucle doit être exécutée. Ceci est généralement géré en déclarant une variable de compteur spéciale, puis en augmentant (ou en diminuant) la variable de 1à chaque itération de la boucle.

Tout semble fonctionner comme il se doit, mais ce n'est pas très pratique. Avant la boucle, nous définissons la valeur initiale de la variable compteur. Ensuite, dans la condition, nous vérifions s'il a déjà atteint la valeur finale. Mais nous modifions généralement la valeur à la toute fin du corps de la boucle.

Et si le corps de la boucle est grand ? Ou si nous avons plusieurs boucles imbriquées ? En général, dans ces cas, il est souhaitable de collecter toutes ces informations sur les variables de compteur en un seul endroit. Et c'est pourquoi nous avons la forboucle en Java. Ca n'a pas l'air très compliqué non plus :

for (statement 1; condition; statement 2)
{
   block of statements
}

Une whileboucle a juste une condition entre parenthèses, mais une forboucle ajoute deux instructions, séparées par des points-virgules.

La réalité est plus simple qu'il n'y paraît : le compilateur convertit une forboucle en une whileboucle ordinaire comme ceci :

statement 1;
while (condition)
{
   block of statements
   statement 2;
}

Ou mieux encore, démontrons cela avec un exemple. Les deux extraits de code ci-dessous sont identiques.

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

int i = 0;
while (i < 20)
{
   System.out.println(i);
   i++;
}

Nous venons de rassembler en un seul endroit tout le code qui se rapporte à la ivariable compteur.

Dans une forboucle, l'instruction 1 est exécutée une seule fois, avant que la boucle elle-même ne commence. Cela peut être vu clairement dans le deuxième extrait de code

l'instruction 2 est exécutée le même nombre de fois que le corps de la boucle, et chaque fois qu'elle est exécutée après que le corps entier de la boucle a été exécuté

2. Où la forboucle est utilisée

La forboucle est probablement le type de boucle le plus utilisé en Java. Il est utilisé partout, pour les programmeurs c'est juste plus clair et plus pratique qu'une whileboucle. Pratiquement n'importe quelle whileboucle peut être convertie en forboucle.

Exemples:

int i = 3;
while (i >= 0)
{
   System.out.println(i);
   i--;
}

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

int i = 0;
while (i < 3)
{
   System.out.println(i);
   i++;
}

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

boolean isExit = false;
while (!isExit)
{
   String s = console.nextLine();
   isExit = s.equals("exit");
}

for (boolean isExit = false; !isExit; )
{
   String s = console.nextLine();
   isExit = s.equals("exit");
}

while (true)
   System.out.println("C");

for (; true; )
   System.out.println("C");

while (true)
{
   String s = console.nextLine();
   if (s.equals("exit"))
      break;
}

for (; true; )
{
   String s = console.nextLine();
   if (s.equals("exit"))
      break;
}

Faites attention au dernier exemple. Les instructions pour travailler avec le compteur de boucle sont manquantes. Il n'y a pas de compteur et pas de déclaration.

Dans une forboucle, Java permet d'omettre "l'instruction pour initialiser le compteur" et "l'instruction pour mettre à jour le compteur". Même l'expression qui définit la condition de boucle peut être omise.

3. Nuances d'utilisation de la forboucle

Un point important sur l'utilisation fordes boucles et des instructions breaket continue.

Une breakinstruction dans une forboucle fonctionne de la même manière que dans une whileboucle — elle termine la boucle immédiatement. Une continueinstruction ignore le corps de la boucle, mais pas statement 2(ce qui modifie le compteur de boucle).

Jetons un autre regard sur la façon dont les boucles foret whilesont liées.

for (statement 1; condition; statement 2)
{
   block of statements
}

statement 1;
while (condition)
{
   block of statements
   statement 2;
}

Si une continueinstruction est exécutée dans une forboucle , le reste du bloc d'instructions est ignoré, mais l'instruction 2 (celle qui fonctionne avec la forvariable compteur de la boucle) est toujours exécutée.

Revenons à notre exemple en sautant des nombres divisibles par 7.

int i = 1;
while (i <= 20)
{
   if ( (i % 7) == 0) continue;
   System.out.println(i);
   i++;
}

for (int i = 1; i <= 20; i++)
{
   if ( (i % 7) == 0) continue;
   System.out.println(i);
}

Le code qui utilise la whileboucle ne fonctionnera pas - i ne sera jamais supérieur à 7. Mais le code avec la forboucle fonctionnera bien.

4. Comparer les boucles for : Java vs Pascal

Au fait, Pascal a aussi une Forboucle. En général, pratiquement tous les langages de programmation en ont un. Mais chez Pascal c'est super clair. Exemples:

For i := 1 to 10 do
Begin
   Writeln(i);
End;

for (int i = 1; i <= 10; i++)
{
   System.out.println(i);
}

For i := 1 to 10 do step 2
Begin
   Writeln(i);
End;

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

For i := 10 downto 0 do step 2
Begin
   Writeln(i);
End;

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