లూప్‌కు అంతరాయం కలిగించడం

"హాయ్, అమిగో!

"హాయ్ ఎల్లీ."

"మీరు ఇప్పటికే లూప్‌లను అధ్యయనం చేసారు మరియు అది బాగుంది."

"నేను అంగీకరిస్తున్నాను! ఇప్పుడు అవి లేకుండా ఎలా జీవించాలో నాకు పూర్తిగా తెలియదు."

"కొన్నిసార్లు మీరు వాటిని లేకుండా చేయవచ్చు... కానీ చాలా తరచుగా మీకు అవి అవసరమవుతాయి. ఈ రోజు మనం షెడ్యూల్ కంటే ముందుగానే మీరు లూప్ నుండి బయటపడాల్సిన పరిస్థితి గురించి మాట్లాడబోతున్నాము."

"మీ ఉద్దేశ్యం, లూప్‌ని కొనసాగించే షరతు నిజం అయితే, మీరు ఇంకా లూప్ నుండి నిష్క్రమించవలసి వచ్చినప్పుడు?"

"సరిగ్గా! కొన్నిసార్లు మీరు ఇప్పటికే ప్రోగ్రామర్‌గా ఉన్నారు. ఏమైనప్పటికీ, షెడ్యూల్ కంటే ముందే లూప్ నుండి బయటపడేందుకు, మీరు బ్రేక్ స్టేట్‌మెంట్‌ను ఉపయోగించవచ్చు . ఈ క్రింది ఉదాహరణను చూడండి:

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

"అద్భుతం! నేను ఈ తప్పు చేయకుండా ప్రయత్నిస్తాను."

"నేను మీ వాగ్దానాన్ని గుర్తుంచుకుంటాను!"