జావాలో కాసేపు లూప్ అంటే ఏమిటి మరియు దానిని ఎలా ఉపయోగించాలి?

జావా భాష అనేక ఉచ్చులతో పనిచేయడానికి మీకు అందిస్తుంది. ఒక నిర్దిష్ట షరతు సంతృప్తి చెందే వరకు పదేపదే స్టేట్‌మెంట్‌ల సమితిని అమలు చేయడానికి ప్రాథమికంగా ఉపయోగిస్తారు. ఇక్కడ, జావాలోని ‘ఉండగా’ లూప్ గురించి మీకు చెప్తాను. ఈ వ్యాసంలో చేర్చబడిన విషయాలు క్రింద పేర్కొనబడ్డాయి:

• జావాలో లూప్ అయితే ఏమిటి?
  • అయితే లూప్ యొక్క సింటాక్స్
  • ప్రాక్టికల్ ప్రదర్శన
• లూప్ అయితే అనంతం అంటే ఏమిటి?
  • లూప్ అయితే అనంతం యొక్క సింటాక్స్
  • ప్రాక్టికల్ ప్రదర్శన

ప్రారంభిద్దాం!

జావాలో కాసేపు లూప్ అంటే ఏమిటి?

ప్రోగ్రామ్ యొక్క కొంత భాగాన్ని మళ్లీ మళ్లీ మళ్ళించడానికి జావా అయితే లూప్ ఉపయోగించబడుతుంది. పునరావృత సంఖ్య పరిష్కరించబడకపోతే, మీరు లూప్ అయితే ఉపయోగించవచ్చు.

కాసేపు లూప్ ఎలా పనిచేస్తుందో చిత్ర చిత్ర ప్రాతినిధ్యం:

పై రేఖాచిత్రంలో, అమలు ప్రారంభమైనప్పుడు మరియు పరిస్థితి తప్పుగా తిరిగి వచ్చినప్పుడు, అప్పుడు కాసేపు లూప్ తర్వాత తదుపరి స్టేట్‌మెంట్‌కు దూకుతుంది. మరోవైపు, పరిస్థితి నిజమైతే, అయితే లూప్ లోపల స్టేట్మెంట్ అమలు అవుతుంది.

అయితే లూప్ ఇన్ పై ఈ కథనంతో కదులుతోంది , వాక్యనిర్మాణం చూద్దాం:

సింటాక్స్:

(షరతు) {// కోడ్ బ్లాక్ అమలు చేయబడాలి}

ఇప్పుడు నేను మీకు వాక్యనిర్మాణాన్ని చూపించాను, ఇక్కడ ఒక ఉదాహరణ ఉంది:

జావాస్క్రిప్ట్లో హెచ్చరిక ఎలా చేయాలి

ప్రాక్టికల్ అమలు:

తరగతి ఉదాహరణ {పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ అర్గ్స్ []) {int i = 10 అయితే (i> 1) {System.out.println (i) i--}}}

అవుట్పుట్ :

10
9
8
7
6
5
4
3
2

తరువాత, మరొక ఉదాహరణను చూద్దాం:

జావాలో అయితే లూప్ యొక్క మరొక ఉదాహరణ:

// జావా అయితే లూప్ ఉదాహరణ ప్యాకేజీ లూప్స్ దిగుమతి java.util.Scanner పబ్లిక్ క్లాస్ అయితే లూప్ {ప్రైవేట్ స్టాటిక్ స్కానర్ sc పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ [] అర్గ్స్) {int సంఖ్య, sum = 0 sc = new Scanner (System.in) సిస్టమ్. out.println ('n దయచేసి 10 కంటే తక్కువ ఏదైనా పూర్ణాంక విలువను నమోదు చేయండి:') సంఖ్య = sc.nextInt () అయితే (సంఖ్య<= 10) { sum = sum + number number++ } System.out.format(' Sum of the Numbers From the While Loop is: %d ', sum) } } 

అవుట్పుట్ :

దయచేసి 10: 7 క్రింద ఏదైనా పూర్ణాంక విలువను నమోదు చేయండి
లూప్ నుండి సంఖ్యల మొత్తం: 34

మునుపటి ఉదాహరణతో పోలిస్తే పైన వివరించిన ఉదాహరణ కొంచెం క్లిష్టంగా ఉంటుంది. దీన్ని దశల వారీగా వివరిస్తాను.

ఈ జావాలో లూప్ ఉదాహరణలో, యంత్రం 10 కంటే తక్కువ ఏదైనా పూర్ణాంక విలువను నమోదు చేయమని వినియోగదారుని అడుగుతుంది. తరువాత, అయితే లూప్ లోపల ఉన్న లూప్ మరియు కండిషన్ ఇచ్చిన సంఖ్య 10 కన్నా తక్కువ లేదా సమానమని హామీ ఇస్తుంది.

ఇప్పుడు, వినియోగదారు ఎంటర్ చేసిన విలువ = 7 మరియు నేను మొత్తం = 0 ను ప్రారంభించాను

పునరావృతం ఈ విధంగా పనిచేస్తుంది: (కోడ్‌లో వ్రాసిన సమయంలో లూప్‌పై దృష్టి పెట్టండి)

మొదటి పునరావృతం:

sum = sum + number
sum = 0 + 7 ==> 7
ఇప్పుడు, సంఖ్య 1 (సంఖ్య ++) ద్వారా పెంచబడుతుంది

రెండవ పునరావృతం

ఇప్పుడు మొదటి పునరావృతంలో సంఖ్య మరియు మొత్తం రెండింటి విలువలు ఇలా మార్చబడ్డాయి: సంఖ్య = 8 మరియు మొత్తం = 7
sum = sum + number
sum = 7 + 8 ==> 15
మళ్ళీ, సంఖ్య 1 (సంఖ్య ++) ద్వారా పెంచబడుతుంది

మూడవ పునరావృతం

ఇప్పుడు, రెండవ పునరావృతంలో, సంఖ్య మరియు మొత్తం రెండింటి విలువలు ఇలా మార్చబడ్డాయి: సంఖ్య = 9 మరియు మొత్తం = 15
sum = sum + number
sum = 15 + 9 ==> 24
అదే నమూనాను అనుసరించి, సంఖ్య మళ్లీ 1 (సంఖ్య ++) ద్వారా పెంచబడుతుంది.

నాల్గవ పునరావృతం

జావా యొక్క మూడవ మళ్ళా లూప్‌లో, సంఖ్య మరియు మొత్తం రెండింటి విలువలు ఇలా మార్చబడ్డాయి: సంఖ్య = 10 మరియు మొత్తం = 24
sum = sum + number
sum = 24 + 10 ==> 34

చివరగా, ఈ సంఖ్య చివరిసారిగా 1 (సంఖ్య ++) ద్వారా పెంచబడుతుంది.

జావాలో ఆదర్శం ఏమిటి

ఇక్కడ, సంఖ్య = 11. కాబట్టి, అయితే లూప్‌లో ఉన్న పరిస్థితి విఫలమవుతుంది.

చివరికి, System.out.format స్టేట్మెంట్ మీరు పైన చూడగలిగినట్లుగా అవుట్పుట్ను ప్రింట్ చేస్తుంది!

మరింత కదులుతోంది,

మీరు గుర్తుంచుకోవలసిన ఒక విషయం ఏమిటంటే, మీరు లూప్ అయితే లోపల ఇంక్రిమెంట్ లేదా తగ్గింపు స్టేట్‌మెంట్‌ను ఉపయోగించాలి, తద్వారా ప్రతి పునరావృతంలో లూప్ వేరియబుల్ మారుతుంది, తద్వారా ఏదో ఒక సమయంలో పరిస్థితి తప్పుగా వస్తుంది. ఈ విధంగా మీరు అయితే లూప్ అమలును ముగించవచ్చు. లేకపోతే, లూప్ నిరవధికంగా అమలు అవుతుంది. ఇటువంటి సందర్భాల్లో, లూప్ నిరవధికంగా అమలు చేయబడినప్పుడు, లూప్ ఇన్ చేస్తున్నప్పుడు మీరు అనంతం యొక్క భావనను ఎదుర్కొంటారు , ఇది మా తదుపరి చర్చా అంశం!

జావాలో లూప్ అయితే అనంతం

మీరు లూప్‌లో ‘ట్రూ’ దాటిన క్షణం, అనంతమైన లూప్ ప్రారంభించబడుతుంది.

సింటాక్స్ :

(నిజం) {ప్రకటన (లు) while

ప్రాక్టికల్ ప్రదర్శన

జావాలో అనంతమైన లూప్ యొక్క ఉదాహరణను మీకు చూపిస్తాను:

తరగతి ఉదాహరణ {పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ అర్గ్స్ []) {int i = 10 అయితే (i> 1) {System.out.println (i) i ++}}}

ఇది అనంతమైన లూప్, కనుక ఇది అంతం కాదు. ఎందుకంటే కోడ్‌లోని షరతు i> 1 అని చెబుతుంది, ఇది మేము లూప్ లోపల i విలువను పెంచుతున్నందున ఇది ఎల్లప్పుడూ నిజం అవుతుంది.

దీనితో, నేను ఈ బ్లాగ్ చివరికి చేరుకున్నాను. మీ జావా జ్ఞానానికి పైన పంచుకున్న కంటెంట్ అదనపు విలువను జోడిస్తుందని నేను నిజంగా ఆశిస్తున్నాను. జావా ప్రపంచాన్ని కలిసి అన్వేషిద్దాం. వేచి ఉండండి!

చూడండి ప్రపంచవ్యాప్తంగా విస్తరించి ఉన్న 250,000 మందికి పైగా సంతృప్తికరమైన అభ్యాసకుల నెట్‌వర్క్‌తో విశ్వసనీయ ఆన్‌లైన్ లెర్నింగ్ సంస్థ ఎడురేకా చేత. ఎడురేకా యొక్క జావా J2EE మరియు SOA శిక్షణ మరియు ధృవీకరణ కోర్సు జావా డెవలపర్‌గా ఉండాలనుకునే విద్యార్థులు మరియు నిపుణుల కోసం రూపొందించబడింది. ఈ కోర్సు మీకు జావా ప్రోగ్రామింగ్‌లోకి రావడానికి మరియు హైబర్నేట్ & స్ప్రింగ్ వంటి వివిధ జావా ఫ్రేమ్‌వర్క్‌లతో పాటు కోర్ మరియు అడ్వాన్స్‌డ్ జావా కాన్సెప్ట్‌లకు శిక్షణ ఇవ్వడానికి రూపొందించబడింది.

మాకు ప్రశ్న ఉందా? దయచేసి ఈ ‘‘ జావా ఇన్ లూప్ జావా ’బ్లాగ్’ యొక్క వ్యాఖ్యల విభాగంలో పేర్కొనండి మరియు మేము వీలైనంత త్వరగా మిమ్మల్ని సంప్రదిస్తాము.