జావా నెస్టెడ్ లూప్స్

జావా, ఇతర ప్రోగ్రామింగ్ లాంగ్వేజ్‌ల వలె, సమూహ లూప్‌లకు మద్దతు ఇస్తుంది. దీని అర్థం లూప్‌లోని లూప్ మాత్రమే. ఈ ఆర్టికల్‌లో, జావాలో నెస్టెడ్ లూప్‌లతో ఎలా పని చేయాలో మనం కనుగొనబోతున్నాం.

జావా నెస్టెడ్ లూప్‌లు

ఒక లూప్ మరొక లూప్ లోపల ఉంచినట్లయితే దానిని నెస్టెడ్ అంటారు. మొదటి పాస్‌లో, బాహ్య లూప్ అంతర్గత లూప్‌ను పిలుస్తుంది, ఇది పూర్తి అయ్యే వరకు నడుస్తుంది, దాని తర్వాత నియంత్రణ బాహ్య లూప్ యొక్క శరీరానికి బదిలీ చేయబడుతుంది. రెండవ పాస్‌లో, బయటి లూప్ మళ్లీ లోపలికి కాల్ చేస్తుంది. మరియు బాహ్య లూప్ ముగిసే వరకు. జావాలో నాలుగు రకాల లూప్‌లు ఉన్నాయి:

• లూప్ కోసం

• అయితే లూప్

• do...while loop

• ప్రతి లూప్ కోసం

అవన్నీ సమూహ లూప్‌లకు మద్దతు ఇస్తాయి. నెస్టెడ్-లూప్ కన్‌స్ట్రక్ట్‌లు తప్పనిసరిగా రెండు షరతులను నెరవేర్చినప్పుడు ఉపయోగించబడతాయి, ఒకటి మరొకదానిపై ఆధారపడి ఉంటుంది. ఉదాహరణకు, మీరు రెండు డైమెన్షనల్ మ్యాట్రిక్స్, సెమీ పిరమిడ్ లేదా గుణకార పట్టికను ప్రదర్శించాల్సిన అవసరం ఉంటే.

జావా నెస్టెడ్ లూప్‌లు ఎలా పని చేస్తాయి

బహుశా జావాలో ఎక్కువగా ఉపయోగించే లూప్ , చాలా భాగం ఎందుకంటే ఇది చాలా బహుముఖమైనది మరియు దానితో కోడ్ చదవడం చాలా సులభం. నెస్టెడ్ ఫర్ లూప్ కోసం సాధారణ సింటాక్స్ ఇక్కడ ఉంది :

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

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

అతను ఎలా పని చేస్తాడు? బాహ్య లూప్ ప్రారంభమవుతుంది. అప్పుడు నెస్టెడ్ ఫర్ లూప్ పనిని ప్రారంభించి, షరతు నెరవేరే వరకు దాని సూచిక గుండా వెళుతుంది మరియు మళ్లీ పనిని బాహ్య లూప్‌కు పంపుతుంది మరియు బాహ్య లూప్ యొక్క స్థితిని చేరుకునే వరకు ఇది జరుగుతుంది. కొంచెం గమ్మత్తుగా అనిపిస్తుంది, కాదా? సరే, ఒక నిర్దిష్ట ఉదాహరణతో అర్థం చేసుకోవడం చాలా సులభం అవుతుంది, కాబట్టి దానికి వెళ్దాం.

లూప్ కోడ్ ఉదాహరణ కోసం నెస్ట్ చేయబడింది

ఇక్కడ ఒక క్లాసిక్ ఉదాహరణ. లూప్‌ల కోసం రెండింటిని ఉపయోగించి సగం పిరమిడ్‌ను ప్రింట్ చేద్దాం . వాటిలో ఒకటి గూడులో ఉంది.

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

       }
   }
}

అవుట్‌పుట్ మునుపటి ఉదాహరణలో వలె ఉంటుంది: డూ ...వైల్ లూప్ వైల్ లూప్ మాదిరిగానే ఉంటుంది . ప్రధాన వ్యత్యాసం ఏమిటంటే, డూ ...వైల్ లూప్ వ్యక్తీకరణ తనిఖీకి ముందు ఒకసారి అమలు చేయబడుతుంది.

Nested foreach loops కోడ్ ఉదాహరణ

లూప్ కోసం ప్రతి లూప్‌ను మామూలుగా గూడులో ఉంచవచ్చు . 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("");
           }
       }
}

అవుట్‌పుట్:

లూప్ ఉదాహరణ కోసం మరియు అయితే మిక్స్డ్

కొన్నిసార్లు మనం ఒకదానికొకటి లోపల వివిధ రకాల లూప్‌లను గూడు కట్టుకోవచ్చు. ఉదాహరణకు , లోపల అయితే లేదా లోపల ప్రతి కోసం . అయితే, ఇది ఉత్తమ ప్రోగ్రామింగ్ అభ్యాసం కాదు. ఇటువంటి నిర్మాణాలు కోడ్ యొక్క రీడబిలిటీని గణనీయంగా దెబ్బతీస్తాయి. కాబట్టి ప్రొఫెషనల్ ప్రోగ్రామర్లు ఒకదానితో మరొకటి కలపకుండా ప్రయత్నిస్తారు. బాగా, వారు చేస్తారు, కానీ అది నిజంగా అవసరమైతే మాత్రమే. మరియు మరొక చిన్న నియమం: మీరు అయితే మరియు కోసం మధ్య ఎంచుకుంటే , సాధ్యమైన చోట ఉపయోగించండి . ఏది ఏమైనప్పటికీ , ఇక్కడ మనం లూప్ కోసం ఒక ఉదాహరణను ఉపయోగించబోతున్నాము . మన సెమీ పిరమిడ్‌ని మళ్లీ నిర్మించుకుందాం.

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

       }
   }
}

అవుట్‌పుట్ ఆశ్చర్యం లేకుండా ఉంది: