ஜாவா ஃபார் லூப்

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

ஜாவாவில் லூப் எழுதுவது எப்படி? பொதுவாக வளையத்திற்கு

ஃபார் லூப் சில அறிக்கைகளை குறிப்பிட்ட எண்ணிக்கையில் செயல்படுத்துகிறது. எடுத்துக்காட்டாக, ஐம்பது முறை "நான் அப்படி இருக்கக்கூடாது, ஹோ-ஹோ, ஹோ" என்று எழுதுவது அல்லது உங்கள் நண்பர்கள் அனைவருக்கும் அழைப்பிதழ்களை அனுப்புவது இந்த வகையான வளையத்திற்கான பொதுவான பணியாகும். லூப்பின் மிகவும் பொதுவான பதிப்பின் தொடரியல்:

for ([counter initialization]; [checking conditions]; [changing of the counter])
{
    //  statements
}

துவக்க வெளிப்பாடு ஒரு முறை செயல்படுத்தப்படுகிறது, பின்னர் நிபந்தனை மதிப்பீடு செய்யப்படுகிறது, இது பூலியன் வெளிப்பாடாக இருக்க வேண்டும்.

• லூப் தொடங்கும் போது துவக்கங்கள் செயல்படுத்தப்படும்.
• நிபந்தனைகள் தவறானவை என மதிப்பிடும்போது, ​​​​எங்கள் லூப் அதன் வேலையை நிறுத்துகிறது.

கவுண்டர் மாறுகிறது, வழக்கமாக லூப் மூலம் ஒவ்வொரு மறு செய்கைக்குப் பிறகும் அதிகரிப்பு (அல்லது குறைப்பு) நடக்கும். மூன்று லூப் வெளிப்பாடுகளில் ஏதேனும் ஒன்றை நீங்கள் தவிர்க்கலாம் (தொடக்கம், நிலையை சரிபார்த்தல், கவுண்டரை மாற்றுதல்). லூப்பின் அடுத்த கட்டத்திற்கு முன் லூப் நிலை சரிபார்க்கப்பட்டது. நிபந்தனை தவறாக இருந்தால், நிரல் லூப்பிலிருந்து வெளியேறி, கட்டுமானத்திற்கான வழிமுறைகளைப் பின்பற்றி தொடரவும். இங்கே நாம் for loop இன் தொகுதி வரைபடம் உள்ளது.

ஜாவாவில் லூப்பிற்கு எவ்வாறு பயன்படுத்துவது. எளிய உதாரணம்.

இங்கே லூப் உதாரணத்திற்கு ஒரு குறிப்பிட்ட ஜாவா உள்ளது. பத்து முறை எழுதுவோம் "வணக்கம்!" ஒவ்வொரு முறையும் இந்த வரியின் எண்ணைக் கொண்ட புதிய வரியிலிருந்து வரும். நாம் பின்வரும் வெளியீட்டைப் பெற வேண்டும்:

1. வணக்கம்!
2. வணக்கம்!
3. வணக்கம்!
4. வணக்கம்!
5. வணக்கம்!
6. வணக்கம்!
7. வணக்கம்!
8. வணக்கம்!
9. வணக்கம்!
10. வணக்கம்!

இந்த சிக்கலை தீர்க்கும் எங்கள் ஜாவா நிரல் இங்கே:

public class ForExample {
   public static void main(String[] args) {
       for (int i = 0; i < 10; i++) {
           System.out.println(i + 1 + ". Hello!");
       }
   }
}

எப்படி இது செயல்படுகிறது?

படி 1. எதிர் i = 0. லூப் எங்கள் நிலையை சரிபார்க்கிறது, i << 10, எனவே, loop அறிக்கைகள் செயல்படுத்தப்படுகின்றன. இது "1. ஹலோ!" என்ற சொற்றொடரை அச்சிடுகிறது. 1 என்பது ஒரு சரம் i + 1 (ஏனென்றால் நாம் பூஜ்ஜியத்தில் இருந்து கணக்கிட்டோம், ஆனால் முதல் வரி இன்னும் முதலாவதாக உள்ளது). கவுண்டர் ஐ அதிகரிக்கப்பட்டுள்ளது. இப்போது, ​​i = 1. படி 2. எதிர் i = 1. i < 10, எனவே "2. வணக்கம்!" மற்றும் i + 1 = 2. … படி 10. எதிர் i = 9, எங்களிடம் "10. ஹலோ!" மற்றும் நான் 10 ஆக அதிகரிக்கப்பட்டுள்ளது. படி 11. எதிர் i = 10. i < 10 ? இல்லை, அது பொய். எனவே, வளையம் முடிந்தது.

லூப் மற்றும் ஃபார் லூப்: வேறுபாடுகள் மற்றும் ஒற்றுமைகள்

ஜாவாவில் காலவரையற்ற லூப் அல்லது பூலியன் நிபந்தனை உண்மையாக இருந்தால் லூப் தொடர்ந்து செயல்படுத்தப்படும். while லூப்பின் தொடரியல்:

while (boolean condition)
       {
            loop statements...
       }

பெரும்பாலும் நீங்கள் எந்த ஒரு வளையத்தை பயன்படுத்த விரும்புகிறீர்கள் என்பதை நீங்கள் தேர்வு செய்யலாம். சில நேரங்களில் அவை மிகவும் நெருக்கமாக இருக்கும், நீங்கள் இரண்டையும் பயன்படுத்தலாம். எடுத்துக்காட்டாக, அதே பணிக்கான குறியீடு இங்கே உள்ளது (பத்து முறை "ஹலோ!" என்று பல வரிகளுடன் எழுதுதல்) while லூப்பில் எழுதப்பட்டது:

public class ForAndForEach {
   public static void main(String[] args) {
       int j = 0;  //  we use the counter this way 
       while (j < 10) {
           System.out.println(j + 1 + ". Hello!");
           j++;
       }
   }
}

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

ஜாவாவில் லூப்பில் இருந்து வெளியேறுவது எப்படி

வழக்கமாக ஒரு ஃபார் லூப் ஒரு ஓட்டம் போல் இயங்குகிறது மற்றும் ஒரு நிபந்தனை தவறான மதிப்பை எடுக்கும் போது ஒரு லூப்பில் இருந்து வெளியேற இயற்கையான வழி. இருப்பினும், நிபந்தனையின் தவறான மதிப்பைப் பெறுவதற்கு முன், வளையத்திலிருந்து வெளியேற உங்களை அனுமதிக்கும் இரண்டு கட்டுப்பாட்டு அறிக்கைகள் உள்ளன - உடைத்து தொடரவும்.

• லூப் நிலை தவறானதாக மதிப்பிடப்பட்டதைப் போல, பிரேக் தற்போதைய லூப் பாடியிலிருந்து வெளியேற அனுமதிக்கிறது.
• Continue ஆனது ஸ்டேட்மென்ட்களை இயக்காமல் அடுத்த கட்டத்திற்கு (கவுண்டரை மீண்டும் செய்யும்) லூப்பை தாவ வைக்கிறது.

இடைவேளையைப் பயன்படுத்தி அடுத்த சிக்கலைத் தீர்க்கலாம் மற்றும் தொடரலாம். எங்களிடம் பல பெயர்கள் உள்ளன, மேலும் இந்த வரிசையில் இருந்து அந்நியர்களைத் தவிர அனைவருக்கும் வணக்கம் கூறுகிறோம். எனவே நமது சுழற்சியின் போது "அந்நியன்" சரத்தை நாம் சந்தித்தால் அதிலிருந்து வெளியேறுவோம் (வெளியே சென்று வேறு எவருக்கும் வணக்கம் சொல்ல நிறுத்தவும்).

public class ForBreakExample {
   public static void main(String[] args) {
       String[] names = {"Mike", "Dustin", "Stranger", "Lucas", "Will"};
       for (int i = 0; i < names.length; i++) {
//  how to break out of a for loop, java: check if we have any "Stranger" in  //  our array            
if (names[i].equals("Stranger")) {
               System.out.println("I don't chat with strangers");
               break;
           }
           System.out.println("Hello," + names[i]);
       }
   }
}

எங்கள் நிரல் செயல்பாட்டின் முடிவு:

Hello,Mike
Hello,Dustin
I don't chat with strangers

பார்க்கவா? லூகாஸ் மற்றும் வில் ஆகியோரை வாழ்த்துவதற்கு முன்பு நாங்கள் வளையத்திலிருந்து ஓடிவிட்டோம். "அந்நியன்" ஒருவரைப் புறக்கணிக்க, மற்ற நண்பர்களுக்கு வணக்கம் சொல்ல, லூப்பிற்குள்ளேயே இருங்கள்.

public class ForContinueExample {
   public static void main(String[] args) {
       String[] names = {"Mike", "Dustin", "Stranger", "Lucas", "Will"};
       for (int i = 0; i < names.length; i++) {
           if (names[i].equals("Stranger")) {
               System.out.println("I don't chat with strangers");
               continue;
           }
           System.out.println("Hello," + names[i]);
       }
   }
}

இதன் விளைவு:

Hello,Mike
Hello,Dustin
I don't chat with strangers
Hello,Lucas
Hello,Will

சிறப்பானது! நாங்கள் எல்லா நண்பர்களையும் வாழ்த்தினோம், ஆனால் அந்நியருடன் பேசவில்லை.

லூப் அல்லது ஒவ்வொருவருக்கும் மேம்படுத்தப்பட்ட பதிப்பு

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

for (type itVar: array)
{
    Block of operators;
}

வகை என்பது மறுசெயல் மாறியின் வகை (வரிசையின் தரவு வகை போன்றது), ItVar என்பது அதன் பெயர், வரிசை வரிசை அல்லது மற்றொரு தரவு அமைப்பு இருக்கலாம், எடுத்துக்காட்டாக, ArrayList. நீங்கள் பார்க்க முடியும் என, கவுண்டர் இல்லை, மறு செய்கை மாறி ஒரு வரிசை அல்லது சேகரிப்பின் உறுப்புகளின் மீது திரும்புகிறது, குறியீட்டு மதிப்புகள் அல்ல. அத்தகைய லூப் செயல்படுத்தப்படும் போது, ​​வரிசை அல்லது சேகரிப்பின் ஒவ்வொரு தனிமத்தின் மதிப்பையும் மறு செய்கை மாறி வரிசையாக ஒதுக்கப்படுகிறது, அதன் பிறகு குறிப்பிட்ட அறிக்கைகளின் தொகுதி (அல்லது ஆபரேட்டர்) செயல்படுத்தப்படுகிறது. கவனம்: வரிசைகள் மற்றும் java.lang.Iterable இடைமுகத்தை செயல்படுத்தும் எந்த வகுப்புகளுக்கும் ஒவ்வொரு லூப் பயன்படுத்தப்படலாம். அந்நியர்களை ("அந்நியன்") புறக்கணித்து, வாழ்த்து நண்பர்களுடன் அதே பிரச்சனையை தீர்ப்போம், ஆனால் இந்த முறை ஒவ்வொரு வளையத்திற்கும் பயன்படுத்தவும்.

public class ForEachExample {
   public static void main(String[] args) {
       String[] names = {"Mike", "Dustin", "Stranger", "Lucas", "Will"};
	//  for each loop, Java code
       for (String name : names) {
           if (name.equals("Stranger")) {
               System.out.println("I don't chat with strangers");
               continue;
           }
           System.out.println("hello, " + name);
       }
   }
}

நீங்கள் கற்றுக்கொண்டதை வலுப்படுத்த, எங்கள் ஜாவா பாடத்திட்டத்திலிருந்து வீடியோ பாடத்தைப் பார்க்க பரிந்துரைக்கிறோம்