లూప్స్ (బ్రేక్ అండ్ రిటర్న్, కంటిన్యూ, లేబుల్స్)

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

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

"మొదటిది కీవర్డ్ బ్రేక్ . మీరు లూప్ బాడీలో ఈ ఆదేశాన్ని ఉపయోగిస్తే, కమాండ్ అమలు చేయబడినప్పుడు లూప్ వెంటనే ముగుస్తుంది. ఇక్కడ ఒక ఉదాహరణ ఉంది:"

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తో ఉన్న లూప్ నుండి కాకుండా, లేబుల్2 లేబుల్ చేయబడిన లూప్ నుండి నిష్క్రమిస్తాము - అనగా మేము వెంటనే k మరియు jతో రెండు లూప్‌ల నుండి నిష్క్రమిస్తాము."

"ఇది ఎంత తరచుగా ఉపయోగించబడుతుంది?"

"నిజాయితీగా చెప్పాలంటే, తరచుగా కాదు, కానీ మీకు ఎప్పటికీ తెలియదు. బహుశా మీరు ఎప్పుడైనా చూస్తారు. ఇవి సింటాక్స్ ఫండమెంటల్స్- మీరు ఇవన్నీ తెలుసుకోవాలి!"

"సరే. ధన్యవాదాలు, బిలాబో."