Java geneste lussen

Java ondersteunt, net als de meeste andere programmeertalen, geneste lussen. Dit betekent slechts een lus in een lus. In dit artikel gaan we ontdekken hoe we met geneste lussen in Java kunnen werken.

Java geneste lussen

Een lus wordt genest genoemd als deze in een andere lus is geplaatst. Bij de eerste doorgang roept de buitenste lus de binnenste lus aan, die tot voltooiing loopt, waarna de controle wordt overgedragen aan het lichaam van de buitenste lus. Bij de tweede doorgang roept de buitenste lus de binnenste weer op. En zo verder totdat de buitenste lus eindigt. Er zijn vier soorten lussen in Java:

• voor lus

• terwijl lus

• do...while lus

• voor elke lus

Ze ondersteunen allemaal geneste lussen. Constructies met een geneste lus worden gebruikt wanneer aan twee voorwaarden moet worden voldaan, de ene afhankelijk van de andere. Als u bijvoorbeeld een tweedimensionale matrix, een halve piramide of een tafel van vermenigvuldiging moet weergeven.

Hoe Java geneste lussen werken

De meest gebruikte lus in Java is waarschijnlijk voor , grotendeels omdat het behoorlijk veelzijdig is en de code ermee vrij gemakkelijk te lezen is. Hier is de algemene syntaxis voor geneste for -lus:

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

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

Hoe werkt hij? De buitenste lus begint. Vervolgens start de geneste for- lus het werk en doorloopt de index totdat aan de voorwaarde is voldaan, en geeft het werk opnieuw door aan de buitenste lus, en dit gebeurt totdat aan de voorwaarde van de buitenste lus is voldaan. Klinkt een beetje lastig, niet? Nou, het zal veel gemakkelijker te begrijpen zijn met een specifiek voorbeeld, dus laten we verder gaan.

Genest voor voorbeeld van luscode

Hier is een klassiek voorbeeld. Laten we een halve piramide afdrukken met twee for- lussen. Een ervan is genest.

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();
       }
      
   }
}

De uitvoer is:

Voorbeeld van geneste while-luscode

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++;

       }
   }
}

De uitvoer is precies hetzelfde als in het vorige voorbeeld: De do...while- lus is vergelijkbaar met de while- lus. Het belangrijkste verschil is dat de do...while -lus één keer wordt uitgevoerd voordat de expressie wordt gecontroleerd.

Codevoorbeeld van geneste foreach-lussen

for-elke lus kan worden genest zoals gebruikelijk voor lus. Hier is het voorbeeld voor een geneste for-elke lus die een tweedimensionale array herhaalt.

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("");
           }
       }
}

De uitvoer is:

Voorbeeld van een gemengde for- en while-lus

Soms kunnen we verschillende soorten lussen in elkaar nesten. Bijvoorbeeld voor inside while of for inside for-each . Het is echter niet de beste programmeermethode. Dergelijke constructies tasten de leesbaarheid van de code aanzienlijk aan. Dus professionele programmeurs proberen het ene niet met het andere te mixen. Dat doen ze wel, maar alleen als het echt nodig is. En nog een kleine regel: als je kiest tussen while en for , gebruik dan waar mogelijk for . Desalniettemin krijgen we hier een voorbeeld van het gebruik van een for- lus in de while . Laten we onze semi-piramide opnieuw bouwen.

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++;

       }
   }
}

De output is zonder verrassingen: