ஒரு வளையத்தை குறுக்கிடுகிறது

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

"ஹாய் எல்லி."

"நீங்கள் ஏற்கனவே லூப்களைப் படித்திருக்கிறீர்கள், அது நன்றாக இருக்கிறது."

"நான் ஒப்புக்கொள்கிறேன்! இப்போது அவர்கள் இல்லாமல் எப்படி வாழ்வது என்று எனக்குத் தெரியவில்லை."

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

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

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

Scanner console = new Scanner(System.in);
boolean isExit = false;
while (!isExit)
{
   String s = console.nextLine();
   isExit = s.equals("exit");
}

"நான் பார்க்கிறேன். நிரல் கன்சோலில் இருந்து வரிகளைப் படிக்கிறது. நீங்கள் உள்ளிட்டால் "exit", isExitமாறி மாறி true, லூப் நிலை , மற்றும் லூப் முடிவடையும். "!isExitfalse

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

break;

break" நாங்கள் இப்போது விவாதித்த உதாரணத்தை மீண்டும் எழுத நீங்கள் அறிக்கையை எவ்வாறு பயன்படுத்தலாம் என்பது இங்கே :

Scanner console = new Scanner(System.in);
while (true)
{
   String s = console.nextLine();
   if (s.equals("exit"))
     break;
}

"ஒருவேளை நான் அதை நினைவில் வைத்திருப்பேன். அது கைக்கு வரும் என்று நான் உணர்கிறேன்."

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

"திரும்பல் என்றால் என்ன?"

"ஒரு லூப் மறு செய்கை என்பது லூப் பாடியின் ஒரு செயல்பாடாகும். continueஅறிக்கையானது லூப்பின் தற்போதைய மறு செய்கையில் குறுக்கிடுகிறது, ஆனால் breakஅறிக்கையைப் போலல்லாமல், அது வளையத்தையே முடிக்காது. அறிக்கையும் சுருக்கமாக உள்ளது:

continue;

"எனவே, continueலூப்பின் சில மறு செய்கைகளை 'தவிர்க்க' விரும்பினால், அறிக்கையை ஒரு வளையத்தில் பயன்படுத்தலாமா?"

break"சரியாக. மற்றும் க்கு இடையே உள்ள வித்தியாசம் உங்களுக்குப் புரிகிறதா continue? மீண்டும் மீண்டும் வராத 20 இலக்கங்களில் ஏழரைக் கண்டுபிடிக்க வேண்டும் என்றால், எந்த வகையான லூப் மற்றும் லூப் குறுக்கீடு அறிக்கையைப் பயன்படுத்துவீர்கள்?

"ம்ம்... நான் எல்லா எண்களையும் பார்த்துவிட்டு, 7ஐக் கண்டுபிடித்தால், ஒரு break.

" ஆல் வகுபடும் எண்களைத் தவிர, 1முதல் வரையிலான எண்களைக் காட்ட வேண்டும் என்றால் என்ன செய்வது ?"207

"சரி, இங்கே எனக்கு ஒருவேளை தேவை continue, ஏனென்றால் நான் லூப்பில் இருந்து வெளியேற விரும்பவில்லை. ஆனால் எனக்கு இன்னும் சரியாகப் புரியவில்லை."

"இந்தச் சிக்கலை எப்படித் தீர்ப்பது என்பதை நான் உங்களுக்குக் காட்டுகிறேன். இந்தக் குறியீடு இப்படித்தான் இருக்கும்."

int i = 1;
while (i <= 20)
{
   if ( (i % 7) == 0 )
     continue;
   System.out.println(i);
   i++;
}

"ஏன் எல்லி என்னை இவ்வளவு சந்தேகமாகப் பார்க்கிறாய்? இங்கே ஏதாவது பிடி இருக்கிறதா?"

"உங்களை ஏமாற்ற முடியாது, அமிகோ! உண்மையில், இந்த குறியீடு சரியாக வேலை செய்யாது . இது முதல் 6 இலக்கங்களைக் காண்பிக்கும், பின்னர் iஎப்போதும் எண்ணில் ஒட்டிக்கொண்டிருக்கும் 7. எல்லாவற்றிற்கும் மேலாக, continueஅறிக்கை மற்ற இரண்டு அறிக்கைகளைத் தவிர்க்கிறது: System.out.println(i)மற்றும் i++. இதன் விளைவாக, நாம் மதிப்பை அடைந்தவுடன் 7, மாறி iமாறுவதை நிறுத்திவிடும், மேலும் நாம் ஒரு எல்லையற்ற சுழற்சியில் இருப்போம். மிகவும் பொதுவான தவறை விளக்குவதற்காக இந்த குறியீட்டை நோக்கத்துடன் எழுதினேன்."

"அதை எப்படி சரி செய்வது?"

"இங்கே இரண்டு விருப்பங்கள் உள்ளன:"

விருப்பம் 1:i செயல்படுத்தும் முன் மாற்றவும் continue, ஆனால் பிறகுi % 7

விருப்பம் 2:i லூப்பின் தொடக்கத்தில் எப்போதும் அதிகரிக்கும் . ஆனால் iஅதன் தொடக்க மதிப்பு இருக்க வேண்டும் 0.

int i = 1;
while (i <= 20)
{
   if ( (i % 7) == 0 )
   {
     i++;
     continue;
   }
   
   System.out.println(i);
   i++;
}

int i = 0;
while (i < 20)
{
   i++;
   if ( (i % 7) == 0)
     continue;
   System.out.println(i);
}

"அருமை! இந்த தவறை செய்யாமல் இருக்க முயற்சிப்பேன்."

"நான் உங்கள் வாக்குறுதியை நினைவில் கொள்கிறேன்!"