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

1. breakஅறிக்கை

முந்தைய பாடத்திலிருந்து ஒரு உதாரணத்தைப் பார்ப்போம்:

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

2. தொடர் அறிக்கை

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

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

continue;

continueசில சூழ்நிலைகளில் லூப் பாடியின் செயல்பாட்டை 'தவிர்க்க' விரும்பினால், லூப்பில் அறிக்கை மிகவும் வசதியானது .

1பணி: நாங்கள் ஒரு நிரலை எழுத விரும்புகிறோம், அதில் இருந்து எண்களை அச்சிடுகிறோம், 20ஆனால் ஆல் வகுபடும் எண்களைத் தவிர்க்கிறோம் 7. இந்தக் குறியீடு இப்படித்தான் இருக்கும்.

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

உண்மையில், இந்த குறியீடு வேலை செய்யாது , ஏனெனில் 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);
}