Boucles en Java

1. Boucles dans notre vie

Très souvent, nos vies nous obligent à effectuer les mêmes actions plusieurs fois. Par exemple, supposons que je doive numériser un document composé de nombreuses pages. Que nous répétions la même procédure encore et encore :

• Placez la première page sur le scanner
• Appuyez sur le bouton de numérisation
• Placez la page suivante sur le scanner

C'est difficile à faire manuellement. Ce serait bien si ce processus pouvait être en quelque sorte automatisé.

Ou considérons un autre exemple : disons que je veux marquer tous les e-mails non lus dans ma boîte de réception comme spam. Il était une fois, je devais sélectionner chaque e-mail un par un et le marquer comme spam.

Mais les programmeurs sont paresseux, ils ont donc automatisé ce processus il y a longtemps : maintenant, il vous suffit de sélectionner n'importe quelle liste de lettres et de cliquer sur "marquer comme spam", puis votre client de messagerie parcourt la liste et déplace chaque e-mail vers le dossier spam.

Que pouvons-nous dire ici ? C'est super pratique lorsqu'un ordinateur ou un programme peut exécuter des centaines ou des milliers d'opérations monotones en un seul clic. Et maintenant, vous allez apprendre à faire cela aussi.

2. whileboucle

L'instruction if-else a considérablement élargi nos capacités de programmation, permettant d'écrire des programmes qui effectuent différentes actions dans différentes situations. Mais il y a encore une chose qui rendra nos programmes d'un ordre de grandeur plus puissants : les boucles .

Java a 4 types de boucles : while, et . Nous allons maintenant creuser dans le tout premier d'entre eux.forfor-eachdo-while

Une whileboucle est très simple. Il se compose de seulement deux parties : une condition et un corps de boucle . Le corps de la boucle est exécuté encore et encore tant que la condition est true. En général, une whileboucle ressemble à ceci :

while (condition)
   statement;

while (condition)
{
   block of statements
}

C'est très simple. L' instruction ou le bloc d'instructions est exécuté encore et encore tant que la condition de boucle est égale à true.

Voici comment cela fonctionne : premièrement, la condition est vérifiée. Si c'est vrai, alors le corps de la boucle est exécuté (l' instruction ou le bloc d'instructions ). Ensuite, la condition est vérifiée à nouveau et le corps de la boucle est exécuté à nouveau. Et ainsi de suite jusqu'à ce que la condition devienne fausse.

Si la condition est toujours vraie , le programme ne s'arrêtera jamais. Il sera définitivement coincé dans la boucle.

Si la condition est fausse la toute première fois qu'elle est vérifiée , alors le corps de la boucle ne sera pas exécuté une seule fois.

3. Exemples de boucles

Voici quelques exemples pratiques de boucles en action.

int n = 5;
while (n > 0)
{
   System.out.println(n);
   n--;
}

5
4
3
2
1

int  n = 0;
while (n < 10)
{
   System.out.println(n);
   n++;
}

0
1
...
8
9

Scanner console = new Scanner(System.in);
while(console.hasNextInt())
{
   int x = console.nextInt();
} 

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

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

Dans l'exemple précédent, la equals()méthode est utilisée pour comparer des chaînes. Si les chaînes sont égales, la fonction renverra true. Si les chaînes ne sont pas égales, alors il retournera false.

4. Boucle dans une boucle

En découvrant les instructions conditionnelles, vous avez vu que vous pouvez les utiliser pour implémenter une logique complexe en combinant plusieurs instructions conditionnelles. En d'autres termes, en utilisant une ifinstruction à l'intérieur d'une ifinstruction.

Vous pouvez faire la même chose avec des boucles. Pour écrire une boucle dans une boucle, vous devez écrire la deuxième boucle à l'intérieur du corps de la première boucle. Cela ressemblera à ceci :

while (condition for outer loop)
{
   while (condition for inner loop)
   {
     block of statements
   }
}

Examinons trois tâches.

Tâche 1 . Disons que nous voulons écrire un programme qui affiche le mot Momà l'écran 4 fois. Une boucle est exactement ce dont nous avons besoin. Et notre code ressemblera à ceci :

int  n = 0;
while (n < 4)
{
   System.out.println("Mom");
   n++;
}

Mom
Mom
Mom
Mom

Tâche 2 . Nous voulons écrire un programme qui affiche 5 lettres As sur une seule ligne. Pour ce faire, nous avons à nouveau besoin d'une boucle. Voici à quoi ressemblera le code :

int n = 0;
while (n < 5)
{
   System.out.print("A");
   n++;
}

AAAAA

Tâche 3 . Nous voulons afficher un rectangle composé de la lettre As. Le rectangle doit être composé de 4 lignes sur 5 colonnes. Pour ce faire, nous avons maintenant besoin d'une boucle imbriquée. Nous allons simplement prendre notre premier exemple (celui où nous produisons 4 lignes) et remplacer le code de sortie d'une ligne par le code du deuxième exemple.

int n = 0;

while (n < 4)
{

   int m = 0;

   
while (m < 5)
{
   System.out.print("A");
   m++;
}

   System.out.println();

   n++;

}
 

AAAAA
AAAAA
AAAAA
AAAAA

Les boucles externe et interne doivent utiliser des variables différentes pour compter le nombre d'itérations de boucle. Nous avons également dû ajouter la System.out.println()commande après la boucle interne, car cette boucle affiche la lettre As sur la même ligne. Une fois que les lettres d'une ligne sont affichées, quelqu'un doit déplacer le curseur vers une nouvelle ligne.

5. Comparaison des boucles Java vs Pascal

Beaucoup d'entre vous ont étudié Pascal au lycée. Pour vous faciliter la compréhension du matériel ici, jetez un œil à cette comparaison de whileboucles écrites en Pascal et Java. Si vous ne connaissez pas Pascal, sautez simplement cette partie.

i := 3;
While i >= 0 Do
   Begin
      WriteLn(i);
      i := i - 1;
   End;

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

i := 0;
While i < 3 Do
   Begin
      WriteLn(i);
      i := i + 1;
   End;

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

IsExit := False;
While Not isExit Do
   Begin
      ReadLn(s);
      isExit :=  (s = 'exit');
   End;

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

While True Do
   WriteLn('C');

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

While True Do
   Begin
     ReadLn(s);
     If s = 'exit' Then
       Break;
   End;

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