ஜாவா உள்ளமைக்கப்பட்ட சுழல்கள்

ஜாவா, மற்ற நிரலாக்க மொழிகளைப் போலவே, உள்ளமைக்கப்பட்ட சுழல்களை ஆதரிக்கிறது. இதன் பொருள் ஒரு வளையத்திற்குள் ஒரு வளையம் மட்டுமே. இந்த கட்டுரையில், ஜாவாவில் உள்ள லூப்களுடன் எவ்வாறு வேலை செய்வது என்பது பற்றி அறியப் போகிறோம்.

ஜாவா உள்ளமைக்கப்பட்ட சுழல்கள்

ஒரு கண்ணி மற்றொரு வளையத்திற்குள் வைக்கப்பட்டால் அது உள்ளமை என்று அழைக்கப்படுகிறது. முதல் பாஸில், வெளிப்புற வளையமானது உள் வளையத்தை அழைக்கிறது, இது நிறைவுக்கு இயங்குகிறது, அதன் பிறகு வெளிப்புற வளையத்தின் உடலுக்கு கட்டுப்பாடு மாற்றப்படுகிறது. இரண்டாவது பாஸில், வெளிப்புற வளையம் மீண்டும் உட்புறத்தை அழைக்கிறது. வெளிப்புற வளைய முடிவடையும் வரை. ஜாவாவில் நான்கு வகையான சுழல்கள் உள்ளன:

• வளையத்திற்கு _

• லூப் போது

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

வெளியீடு:

Nested while loop code உதாரணம்

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

       }
   }
}

வெளியீடு முந்தைய எடுத்துக்காட்டில் உள்ளதைப் போலவே உள்ளது: do ...while loop ஆனது while loop போன்றது . முக்கிய வேறுபாடு என்னவென்றால், டூ ...வேல் லூப் எக்ஸ்ப்ரெஷன் சரிபார்ப்புக்கு முன் ஒருமுறை இயக்கப்படும்.

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

       }
   }
}

வெளியீடு ஆச்சரியங்கள் இல்லாமல் உள்ளது: