Java beágyazott hurkok

A Java a legtöbb programozási nyelvhez hasonlóan támogatja a beágyazott ciklusokat. Ez csak egy hurkot jelent a cikluson belül. Ebben a cikkben megtudjuk, hogyan dolgozhatunk beágyazott hurkokkal a Java nyelven.

Java beágyazott hurkok

Egy hurkot beágyazottnak nevezzük, ha egy másik hurkon belül van elhelyezve. Az első lépésben a külső hurok meghívja a belső hurkot, amely a befejezésig fut, majd a vezérlés átkerül a külső hurok törzsére. A második lépésben a külső hurok ismét hívja a belsőt. És így tovább, amíg a külső hurok véget nem ér. A Java-ban négyféle hurok létezik:

• hurokhoz _

• míg hurok

• do...while loop

• minden hurok számára

Mindegyik támogatja a beágyazott hurkokat. A beágyazott hurok konstrukciókat akkor használjuk, ha két feltételnek kell teljesülnie, az egyik a másiktól függ. Például, ha egy kétdimenziós mátrixot, egy félpiramist vagy egy szorzótáblát kell megjelenítenie.

Hogyan működnek a Java beágyazott hurkok

Valószínűleg a Java leggyakrabban használt ciklusa a -ra vonatkozik , nagyrészt azért, mert meglehetősen sokoldalú, és a kódot is meglehetősen könnyű olvasni. Íme a beágyazott ciklus általános szintaxisa :

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

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

Hogyan működik? A külső hurok elindul. Ezután a beágyazott for ciklus elindítja a munkát, és végigmegy az indexén, amíg a feltétel teljesül, majd ismét átadja a munkát a külső ciklusnak, és ez addig történik, amíg a külső ciklus feltétele nem teljesül. Kicsit trükkösen hangzik, nem? Nos, egy konkrét példával sokkal könnyebb lesz megérteni, úgyhogy térjünk rá.

Beágyazott cikluskód példa

Íme egy klasszikus példa. Nyomtassunk ki egy félpiramist kettős hurkokkal . Az egyik beágyazott.

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

A kimenet a következő:

Beágyazott while cikluskód példa

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

       }
   }
}

A kimenet ugyanaz, mint az előző példában: A do...while ciklus hasonló a while ciklushoz. A fő különbség az, hogy a do...while ciklus törzse egyszer végrehajtásra kerül a kifejezés ellenőrzése előtt.

Beágyazott foreach ciklus kódpélda

A for-each ciklus a ciklushoz szokásos módon beágyazható . Íme egy példa a beágyazott for-each ciklusra, amely 2-dimenziós tömböt iterál.

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

A kimenet a következő:

Vegyes for és while ciklus példa

Néha különböző típusú hurkokat fészkelhetünk egymásba. Például a inside while vagy a inside for-each . Ez azonban nem a legjobb programozási gyakorlat. Az ilyen konstrukciók jelentősen rontják a kód olvashatóságát. A professzionális programozók tehát igyekeznek nem keverni egyiket a másikkal. Hát igen, de csak akkor, ha valóban szükség van rá. És még egy kis szabály: ha a while és a for között választ , használja a for-t, ahol lehetséges. Ennek ellenére itt lesz egy példa a for ciklus használatára a while -ban . Építsük újra a félpiramisunkat.

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

       }
   }
}

A végeredmény meglepetésmentes: