சுழல்கள் (பிரேக் மற்றும் ரிட்டர்ன், தொடர், லேபிள்கள்)

"வணக்கம், அமிகோ!"

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

"முதலாவது கீவேர்ட் பிரேக் ஆகும். இந்த கட்டளையை லூப்பின் உடலில் பயன்படுத்தினால், கட்டளையை இயக்கும் போது லூப் உடனடியாக முடிவடையும். இதோ ஒரு உதாரணம்:"

for (int i = 0; i < 10; i++)
{
System.out.println(i);
if (i > 5)
break;
}

"பிரேக்கை லூப்பில் மட்டும் பயன்படுத்த முடியுமா?"

"ஆம். பிரேக் ஸ்டேட்மென்ட்டை ஒரு லூப்பில் மட்டுமே பயன்படுத்த முடியும். பிரேக் ஸ்டேட்மெண்ட் செயல்படுத்தப்படும்போது, ​​லூப் உடனடியாக முடிவடையும்."

"கிடைத்தது."

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

"இதோ ஒரு உதாரணம்:"

for (int i = 0; i < 10; i++)
{
if (i % 2 == 0)
continue;
System.out.println(i);
}

"எனவே, நிரல் ஒரு லூப்பில் தொடரும் கட்டளையை அடைந்தவுடன், அது லூப்பில் குறியீட்டை இயக்குவதை நிறுத்துமா?"

"இல்லை. பார், ஒரே குறியீட்டை பலமுறை இயக்கும்போது நமக்கு ஒரு லூப் உள்ளது. மேலே உள்ள எடுத்துக்காட்டில், 0 முதல் 9 வரை லூப் உள்ளது, அதாவது லூப்பின் உடல் 10 முறை செயல்படுத்தப்படும். சரியா?"

"ஆம்."

"லூப்பின் உடல் வழியாக ஒரு கடவு ஒரு மறு செய்கை என்று அழைக்கப்படுகிறது. எங்கள் லூப் 10 மறு செய்கைகளைக் கொண்டுள்ளது - வளையத்தின் உடல் பத்து முறை செயல்படுத்தப்படும்."

"ஆம், அது தெளிவாக உள்ளது."

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

"இதோ மற்றொரு உதாரணம்:"

ArrayList list = new ArrayList();
for (Object o: list)
{
if (o == null) continue;
System.out.println(o.toString());
}

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

"சரி, புரிந்தது. இது எவ்வளவு வசதியானது என்று நான் பார்க்கிறேன்."

ஆம் விளையாட்டு மைதானத்தில் அவர்களைப் பற்றி நீங்கள் கேள்விப்பட்டிருப்பதை விட, அவர்கள்

"ஒரு காலத்தில் குறியீட்டில் எந்த வரியிலிருந்தும் எந்த வரிக்கும் செல்ல அனுமதிக்கப்பட்டது. இதை லேபிள்கள் மற்றும் கோட்டோ ஸ்டேட்மென்ட் மூலம் செய்தோம். அது எப்படி இருக்கிறது என்பது இங்கே:"

System.out.println("Make cookies,");
label: System.out.println("not");
System.out.println("war");
goto label;

"இந்த எடுத்துக்காட்டில், கோட்டோ லேபிள் கட்டளை செயல்படுத்தப்பட்ட பிறகு, நிரல் குறிக்கப்பட்ட லேபிளுக்குத் தாவுகிறது .

"பின்னர், அனைவரும் புத்திசாலித்தனமாகி, கோட்டோ அறிக்கையைப் பயன்படுத்த வேண்டாம் என்று முடிவு செய்தனர். ஜாவா கோட்டோவை ஆதரிக்கவில்லை, ஆனால் கோட்டோ என்பது ஒதுக்கப்பட்ட வார்த்தை. பெரிய விஷயமில்லை..."

"அப்படியானால், ஜாவாவில் கோட்டோ மற்றும் லேபிள்கள் இல்லையா?"

"கோட்டோ அறிக்கை இல்லை, ஆனால் லேபிள்கள் உள்ளன!"

"அது எப்படி அவ்வாறு இருக்க முடியும்?"

"ஜாவாவில், லேபிள்களைத் தொடர மற்றும் உடைக்கும் கட்டளைகளுடன் பயன்படுத்தலாம். உங்களிடம் பல உள்ளமைக்கப்பட்ட சுழல்கள் இருக்கும்போது அவை பயன்படுத்தப்படும்."

"உதாரணமாக, உங்களிடம் 5 உள்ளமை லூப்கள் உள்ளன மற்றும் சில நிபந்தனைகள் திருப்திகரமாக இருக்கும் போது, ​​அவற்றில் மூன்றில் இருந்து வெளியேற விரும்புகிறீர்கள், ஆனால் அவை அனைத்தையும் அல்ல. லேபிள்கள் இதைச் செய்வதற்கான ஒரு நேர்த்தியான வழி:"

label1: for (int i = 0; i < 10; i++)
 label2: for (int j = 0; j < 10; j++)
  label3: for (int k =0; k < 10; k++)
   if (i == j && j == k)
    break label2;

"இந்த எடுத்துக்காட்டில், பிரேக் ஸ்டேட்மென்ட் செயல்படுத்தப்படும்போது, ​​k உடன் மாறி k உள்ள லூப்பில் இருந்து வெளியேறாமல், 2 லேபிளிடப்பட்ட லூப்பில் இருந்து வெளியேறுகிறோம் - அதாவது k மற்றும் j உடன் இரண்டு லூப்களில் இருந்து உடனடியாக வெளியேறுவோம்."

"இது எவ்வளவு அடிக்கடி பயன்படுத்தப்படுகிறது?"

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

"சரி. நன்றி, பிலாபோ."