Boucles imbriquées Java

Java, comme la plupart des autres langages de programmation, prend en charge les boucles imbriquées. Cela signifie juste une boucle dans une boucle. Dans cet article, nous allons découvrir comment travailler avec des boucles imbriquées en Java.

Boucles imbriquées Java

Une boucle est dite imbriquée si elle est placée à l'intérieur d'une autre boucle. Lors du premier passage, la boucle externe appelle la boucle interne, qui s'exécute jusqu'à la fin, après quoi le contrôle est transféré au corps de la boucle externe. Au deuxième passage, la boucle externe appelle à nouveau la boucle interne. Et ainsi de suite jusqu'à la fin de la boucle extérieure. Il existe quatre types de boucles en Java :

• pour la boucle

• boucle while

• faire...en boucle

• pour chaque boucle

Tous prennent en charge les boucles imbriquées. Les constructions en boucle imbriquée sont utilisées lorsque deux conditions doivent être remplies, l'une dépendant de l'autre. Par exemple, si vous avez besoin d'afficher une matrice à deux dimensions, une semi-pyramide ou une table de multiplication.

Fonctionnement des boucles imbriquées Java

La boucle la plus utilisée en Java est probablement for , en grande partie parce qu'elle est assez polyvalente et que le code qui l'accompagne est assez facile à lire. Voici la syntaxe générale de la boucle for imbriquée :

// outer loop
for (initialization; condition; increment) {
  //write here your code 

  //nested loop
  for(initialization; condition; increment) {
    //write here your code
  }
..
}

Comment travaille-t-il ? La boucle externe démarre. Ensuite, la boucle for imbriquée démarre le travail et parcourt son index jusqu'à ce que la condition soit remplie, puis passe à nouveau le travail à la boucle externe, et cela se produit jusqu'à ce que la condition de la boucle externe soit remplie. Cela semble un peu délicat, n'est-ce pas? Eh bien, ce sera beaucoup plus facile à comprendre avec un exemple précis, alors passons à autre chose.

Exemple de code de boucle for imbriqué

Voici un exemple classique. Imprimons une demi-pyramide en utilisant deux boucles for . L'un d'eux est imbriqué.

public class NestedLoopsDemo1 {

   public static void main(String[] args) {

       for (int i = 0; i < 10; i++) {
           for (int j = 0; j<=i;  j++)
               System.out.print("*");
           System.out.println();
       }
      
   }
}

La sortie est :

Exemple de code de boucle while imbriquée

public class NestedLoopsDemo2 {

   public static void main(String[] args) {

       int i = 0;
       while (i < 10) {
           int j = 0;
           while (j <= i) {
               System.out.print("*");
               j++;
           }
           System.out.println();
           i++;

       }
   }
}

Le résultat est exactement le même que dans l'exemple précédent : La boucle do...while est similaire à la boucle while . La principale différence est que le corps de la boucle do...while est exécuté une fois avant la vérification de l'expression.

Exemple de code de boucles foreach imbriquées

La boucle for-each peut être imbriquée comme d'habitude pour la boucle. Voici l'exemple d'une boucle for-each imbriquée qui itère un tableau à 2 dimensions.

public class NestedLoops2 {

       public static void main(String[] args)
       {
           int[][] mainArray = { {5, 4, 3, 2, 1}, {7, 8, 9, 10, 11} };

           for (int[] myArray : mainArray)
           {
               for (int i : myArray)
               {
                   System.out.print(i+" ");
               }
               System.out.println("");
           }
       }
}

La sortie est :

Exemple de boucle mixte for et while

Parfois, nous pouvons imbriquer différents types de boucles les unes dans les autres. Par exemple, for inside while ou for inside for-each . Cependant, ce n'est pas la meilleure pratique de programmation. De telles constructions nuisent considérablement à la lisibilité du code. Les programmeurs professionnels essaient donc de ne pas mélanger l'un avec l'autre. Eh bien, ils le font, mais seulement si c'est vraiment nécessaire. Et encore une petite règle : si vous choisissez entre while et for , utilisez for si possible. Néanmoins, nous allons ici avoir un exemple d'utilisation d'une boucle for à l'intérieur du while . Construisons à nouveau notre semi-pyramide.

public class NestedLoopsDemo2 {

   public static void main(String[] args) {
       int i = 0;
       while (i < 10) {
           for (int j = 0; j <= i; j++) {
               System.out.print("*");
           }
           System.out.println();
           i++;

       }
   }
}

Le rendu est sans surprise :