जावा नेस्टेड लूप्स

जावा, अधिकांश अन्य प्रोग्रामिंग भाषाओं की तरह, नेस्टेड लूप का समर्थन करता है। इसका मतलब लूप के भीतर सिर्फ एक लूप है। इस लेख में, हम जावा में नेस्टेड लूप के साथ काम करने के तरीके के बारे में जानने जा रहे हैं।

जावा नेस्टेड लूप

एक लूप को नेस्टेड कहा जाता है यदि इसे दूसरे लूप के अंदर रखा जाता है। पहले पास पर, बाहरी लूप आंतरिक लूप को कॉल करता है, जो पूरा होने तक चलता है, जिसके बाद नियंत्रण बाहरी लूप के शरीर में स्थानांतरित हो जाता है। दूसरे पास पर, बाहरी लूप आंतरिक को फिर से कॉल करता है। और इसी तरह जब तक बाहरी पाश समाप्त नहीं हो जाता। जावा में चार प्रकार के लूप होते हैं:

• पाश के लिए

• जबकि लूप

• करो ... जबकि पाश

• for-प्रत्येक पाश

ये सभी नेस्टेड लूप्स को सपोर्ट करते हैं। नेस्टेड-लूप निर्माण का उपयोग तब किया जाता है जब दो शर्तों को पूरा किया जाना चाहिए, एक दूसरे पर निर्भर करता है। उदाहरण के लिए, यदि आपको द्वि-आयामी मैट्रिक्स, अर्ध-पिरामिड या गुणा तालिका प्रदर्शित करने की आवश्यकता है।

जावा नेस्टेड लूप कैसे काम करते हैं

शायद जावा में सबसे अधिक इस्तेमाल किया जाने वाला लूप बड़े हिस्से में है , क्योंकि यह काफी बहुमुखी है और इसके साथ कोड पढ़ने में काफी आसान है। यहाँ लूप के लिए नेस्टेड के लिए सामान्य सिंटैक्स है :

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

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

वह कैसे काम करता है? बाहरी पाश शुरू होता है। फिर नेस्टेड लूप के लिए काम शुरू होता है और जब तक शर्त पूरी नहीं हो जाती है, तब तक वह अपने सूचकांक से गुजरता है, और फिर से काम को बाहरी लूप में भेजता है, और यह तब तक होता है जब तक कि बाहरी लूप की स्थिति पूरी नहीं हो जाती। थोड़ा मुश्किल लगता है, है ना? खैर, एक विशिष्ट उदाहरण से समझना बहुत आसान होगा, तो चलिए इस पर चलते हैं।

लूप कोड उदाहरण के लिए नेस्टेड

यहाँ एक क्लासिक उदाहरण है। आइए दो for लूप का उपयोग करके आधा पिरामिड प्रिंट करें। उनमें से एक नेस्टेड है।

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

आउटपुट है:

लूप कोड उदाहरण के दौरान नेस्टेड

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

       }
   }
}

आउटपुट पिछले उदाहरण के समान ही है: डू ...वाइल लूप वाइल लूप के समान है । मुख्य अंतर यह है कि डू...वाइल लूप की बॉडी एक्सप्रेशन चेकिंग से पहले एक बार एक्सीक्यूट होती है।

नेस्टेड foreach लूप्स कोड उदाहरण

for-प्रत्येक लूप को लूप के लिए हमेशा की तरह नेस्ट किया जा सकता है । यहां नेस्टेड फॉर-प्रत्येक लूप का उदाहरण दिया गया है जो 2-आयामी सरणी को पुनरावृत्त करता है।

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

आउटपुट है:

मिश्रित के लिए और जबकि पाश उदाहरण

कभी-कभी हम अलग-अलग तरह के लूप एक-दूसरे के अंदर नेस्ट कर सकते हैं। उदाहरण के लिए, अंदर के लिए या अंदर के लिए प्रत्येक के लिए । हालांकि, यह सबसे अच्छा प्रोग्रामिंग अभ्यास नहीं है। इस तरह के निर्माण कोड की पठनीयता को महत्वपूर्ण रूप से प्रभावित करते हैं। इसलिए पेशेवर प्रोग्रामर एक को दूसरे के साथ न मिलाने की कोशिश करते हैं। ठीक है, वे करते हैं, लेकिन सिर्फ अगर यह वास्तव में जरूरत है। और एक और छोटा नियम: यदि आप जबकि और के बीच चयन कर रहे हैं , जहां संभव हो के लिए उपयोग करें। फिर भी, यहां हम थोड़ी देर के अंदर for लूप का उपयोग करने का एक उदाहरण देने जा रहे हैं । आइए फिर से अपना अर्ध-पिरामिड बनाएं।

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

       }
   }
}

आउटपुट आश्चर्य के बिना है: