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

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