జావాలో లూప్ కోసం ఎలా వ్రాయాలి

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

జావాలో ది లూప్

లూప్‌ల కోసం షరతు నెరవేరే వరకు కోడ్ బ్లాక్‌ను అమలు చేయడం కొనసాగుతుంది. ఇది ఒక లూప్ లూప్ ప్రారంభంలో పరిస్థితిని తనిఖీ చేస్తుంది, ముగింపు కాదు. దీని అర్థం షరతు నెరవేరితే, లూప్ ప్రారంభం కాదు.

---

---

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

for([statement1]; [condition]; [statement2]){
//code to execute each loop
}

కీవర్డ్ కోసం లూప్ కోసం సూచిస్తుంది. లూప్ ఎంతకాలం కొనసాగుతుందో నిర్ణయించే పరిస్థితి బ్రాకెట్ల మధ్య ఉంది.

లూప్ ప్రారంభించినప్పుడు మొదటి స్టేట్మెంట్ ఒకసారి అమలు చేయబడుతుంది; లూప్ ఎప్పుడు ఆగిపోతుందో పరిస్థితి వివరిస్తుంది.

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

సాధారణంగా, స్టేట్‌మెంట్‌లు కౌంటర్‌ను సృష్టించడానికి ఉపయోగించబడతాయి మరియు కౌంటర్ నిర్దిష్ట సంఖ్యకు చేరుకున్న తర్వాత పరిస్థితి లూప్‌ను ఆపివేస్తుంది. చివరగా, ప్రతి లూప్‌లో అమలు చేయబడిన కోడ్ గిరజాల బ్రాకెట్‌ల మధ్య ఉంచబడుతుంది.

---

---

public class Main{
public static void main(String[] args) {
for(int i = 1; i <4; i++){
System.out.print(i);
}
}
}
//Output: 123


పై ఉదాహరణలో, for లూప్ విలువను ముద్రించింది i . కీవర్డ్ కోసం లూప్‌ను ప్రారంభిస్తుంది. వేరియబుల్ i మొదట్లో సెట్ చేయబడింది 1. కండిషన్ చెక్ చేస్తుందో లేదో i నాలుగు లేదా అంతకంటే ఎక్కువ. ఇది అలా కాదు, కాబట్టి మా లూప్ అమలు చేయబడుతుంది. లూప్ కోడ్ విలువను ప్రింట్ చేస్తుంది i , ఈ సమయంలో ఇది ఇప్పటికీ 1.

లూప్ కోడ్ పూర్తయిన తర్వాత, i ఒకటి ద్వారా పెరుగుతుంది మరియు లూప్ మళ్లీ ప్రారంభమవుతుంది. మూడవ లూప్ ముగింపులో, i నాలుగుకి పెంచబడింది. తదుపరి లూప్ ప్రారంభమైనప్పుడు, మా పరిస్థితి కలుస్తుంది, కాబట్టి లూప్ ఆగిపోతుంది.

---

---

సంబంధిత: ప్రారంభించినప్పుడు మీరు నేర్చుకోవలసిన కోర్ జావా కాన్సెప్ట్‌లు

లూప్ కోసం నెస్టెడ్

మీరు ఒక లూప్‌ని పట్టుకున్న తర్వాత, మీరు లూప్ కోసం ఒక గూడును సృష్టించడానికి ప్రయత్నించాలి. మీరు మరొక లూప్ లోపల లూప్‌ను కలిగి ఉన్నప్పుడు ఇది జరుగుతుంది. ఇది ఒక అధునాతన టెక్నిక్ ఎందుకంటే రెండు ఉచ్చులు ఎలా సంకర్షణ చెందుతాయో అర్థం చేసుకోవడం కష్టం. లూప్‌లు ఎలా పని చేస్తాయో ఊహించడానికి ఒక మంచి మార్గం లూప్ కోసం ఒక గూడుతో కింది నమూనాను సృష్టించడం.

*
**
***

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

సమూహ లూప్‌ను సృష్టించేటప్పుడు, మీరు మీ కౌంటర్ వేరియబుల్స్ పేరును ఎంచుకున్నప్పుడు జాగ్రత్తగా ఉండండి. తరచుగా ప్రోగ్రామర్లు సాధారణమైన వాటిని ఉపయోగిస్తున్నప్పటికీ i కౌంటర్, బహుళ ఉచ్చులు సంకర్షణ చెందుతున్నప్పుడు సాధారణ కౌంటర్‌లను ఉపయోగించడం గందరగోళంగా మారుతుంది.

for(int lineCounter = 1; lineCounter <4; lineCounter++){
for(int starCounter = 1; starCounter <= lineCounter; starCounter++){
System.out.print('*');
}
System.out.print('
');
}

ఇది ఎలా పనిచేస్తుందో బాగా అర్థం చేసుకోవడానికి ఈ ఉదాహరణ ద్వారా నడుద్దాం.

మన మొదటి లూప్ మనం ఎన్ని లైన్లు తయారు చేస్తామో లెక్కించడం. లూప్ మూడుసార్లు అమలు చేసిన తర్వాత, అది ఆగిపోతుంది.

తదుపరి లూప్ మరింత క్లిష్టమైనది. ఈ లూప్ ప్రతి లైన్‌లో ఎన్ని నక్షత్రాలు ముద్రించబడిందో నియంత్రిస్తుంది. మా నమూనాలో, మేము లైన్ నంబర్ వలె అదే సంఖ్యలో నక్షత్రాలను కోరుకుంటున్నాము. మొదటి లైన్‌లో ఒక నక్షత్రం, రెండవ రెండు మరియు మూడవ మూడు ఉన్నాయి. కాబట్టి, ఆ లూప్ మా ప్రస్తుత లైన్ కౌంటర్ వలె అనేక నక్షత్రాలను ముద్రించాలని మేము కోరుకుంటున్నాము.

మా స్టార్ లూప్ పూర్తయిన తర్వాత, లైన్ లూప్ ప్రింటింగ్ ద్వారా కొత్త లైన్ సృష్టిస్తుంది n , ఇది కొత్త లైన్ కోసం ఆదేశం.

అనంతమైన ఉచ్చులు

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

అనంతమైన లూప్‌ను సృష్టించడానికి, మీరు కింది వాక్యనిర్మాణాన్ని ఉపయోగించవచ్చు:

for(;;){
//code that never stops looping
}

సంబంధిత: జావా ప్రోగ్రామింగ్ నేర్చుకునేటప్పుడు సహాయపడే వెబ్‌సైట్‌లు & యాప్‌లు

అరేతో ఒక లూప్‌ని ఉపయోగించడం

ఒక లూప్‌ని ఉపయోగించడానికి ఒక సాధారణ మార్గం శ్రేణి ద్వారా మళ్లీ చెప్పడం. ఉదాహరణకు, మీరు అన్ని స్ట్రింగ్‌లను శ్రేణిలో ముద్రించాలనుకుంటే, మీరు కేవలం చెప్పలేరు

System.out.print([array]);

ఈ ఆదేశం శ్రేణి గురించి సమాచారాన్ని ప్రింట్ చేస్తుంది, శ్రేణిలోని విషయాలను కాదు. శ్రేణిలోని విషయాలను ముద్రించడానికి, మీరు శ్రేణిలోని ప్రతి మూలకాన్ని ముద్రించాలి. ఇది కోడ్‌కు సమయం తీసుకుంటుంది, కానీ మీరు ప్రతి మూలకం ద్వారా వెళ్ళడానికి లూప్‌ను సృష్టించవచ్చు.

String[] words = {'Hello', ' ', 'World', '!'};

for(int i = 0; i System.out.print(words[i]);
}

గుర్తుంచుకోండి, శ్రేణి స్థానాలు సున్నాతో మొదలవుతాయి, ఒకటి కాదు, కాబట్టి మా లూప్ సున్నా వద్ద ప్రారంభం కావాలని మేము కోరుకుంటున్నాము. మా మొదటి లూప్ ముద్రించబడుతుంది హలో , రెండవ లూప్ ఒక స్పేస్‌ను ప్రింట్ చేస్తుంది, అలాగే. నాల్గవ లూప్ తరువాత, మా కౌంటర్ నాలుగుకి పెంచబడుతుంది, ఇది శ్రేణి పొడవు కంటే తక్కువ కాదు, ఇది కూడా నాలుగు. ఇది లూప్‌ను ఆపివేస్తుంది.

అవుట్‌పుట్:

Hello World!

ప్రతి లూప్ కోసం

మీరు ఒక శ్రేణిపై మళ్ళించడానికి ఒక లూప్‌ని ఉపయోగించగలిగినప్పటికీ, ప్రతి లూప్‌ను ఉపయోగించడం సులభం. ఈ లూప్‌లు ప్రత్యేకంగా శ్రేణుల కోసం రూపొందించబడ్డాయి. A కోసం ప్రతి లూప్ ఒక శ్రేణిలోని ప్రతి మూలకం గుండా వెళుతుంది మరియు కోడ్‌ను అమలు చేస్తుంది. ప్రతి-లూప్‌లు కొద్దిగా భిన్నమైన వాక్యనిర్మాణాన్ని కలిగి ఉంటాయి. కీవర్డ్ కోసం ఇప్పటికీ ఉపయోగించబడుతోంది, కానీ ఒక షరతు పేర్కొనబడలేదు.

for([dataType] [arrayElement] : [array]){
//code to be executed
}

మా మునుపటి ఉదాహరణను ఈ వాక్యనిర్మాణాన్ని ఉపయోగించి ప్రతి లూప్‌గా తిరిగి వ్రాయవచ్చు:

String[] words = {'Hello', ' ', 'World', '!'};

for(String word : words){
System.out.print(word);
}

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

లూప్ కోసం ఎప్పుడు ఉపయోగించాలి

లూప్‌లు మీకు చాలా కోడింగ్‌ను ఆదా చేయగల గొప్ప సాధనాలు. మీ లూప్ ఎన్నిసార్లు అమలు చేయాలనుకుంటున్నారో మీకు ఖచ్చితంగా తెలిసినప్పుడు అవి ఉపయోగించడానికి ఉత్తమమైన లూప్ రకం. మీరు గూళ్లు పెట్టడం ద్వారా లూప్‌ల సంక్లిష్టతను కూడా పెంచవచ్చు.

బహుళ డైమెన్షనల్ శ్రేణులతో పనిచేసేటప్పుడు లూప్‌ల కోసం గూడు కట్టుకోవడం ప్రత్యేకంగా ఉపయోగపడుతుంది. ఉచ్చులు నేర్చుకోవడం సులభం మరియు ప్రారంభకులకు ముఖ్యమైన నైపుణ్యం. అనవసరమైన పునరావృత కోడ్‌ని కోడింగ్ చేయకుండా ఈ టెక్నిక్ మిమ్మల్ని ఖచ్చితంగా కాపాడుతుంది.

ps5 లో ప్లే ఎలా పంచుకోవాలి

షేర్ చేయండి షేర్ చేయండి ట్వీట్ ఇమెయిల్ మీ మొదటి యాప్ రాయడం కోసం 9 ఉత్తమ ఉచిత కోడ్ ఎడిటర్లు

ఒక మంచి కోడ్ ఎడిటర్ ప్రోగ్రామర్ జీవితాన్ని మరింత సులభతరం చేస్తుంది, కానీ మీకు ఏది ఉత్తమమైనది?

తదుపరి చదవండి సంబంధిత అంశాలు

• ప్రోగ్రామింగ్
• జావా
• ప్రోగ్రామింగ్

రచయిత గురుంచి జెన్నిఫర్ సీటన్(21 కథనాలు ప్రచురించబడ్డాయి)

J. సీటన్ ఒక సైన్స్ రైటర్, ఇది సంక్లిష్ట అంశాలను విచ్ఛిన్నం చేయడంలో ప్రత్యేకత కలిగి ఉంది. ఆమె సస్కట్చేవాన్ విశ్వవిద్యాలయం నుండి PhD కలిగి ఉంది; ఆమె పరిశోధన ఆన్‌లైన్‌లో విద్యార్థుల నిశ్చితార్థాన్ని పెంచడానికి ఆట ఆధారిత అభ్యాసాన్ని ఉపయోగించడంపై దృష్టి పెట్టింది. ఆమె పని చేయనప్పుడు, ఆమె చదవడం, వీడియో గేమ్‌లు ఆడటం లేదా తోటపనితో మీరు ఆమెను కనుగొంటారు.

జెన్నిఫర్ సీటన్ నుండి మరిన్ని

మా వార్తాలేఖకు సభ్యత్వాన్ని పొందండి

టెక్ చిట్కాలు, సమీక్షలు, ఉచిత ఈబుక్‌లు మరియు ప్రత్యేకమైన డీల్స్ కోసం మా వార్తాలేఖలో చేరండి!

సభ్యత్వం పొందడానికి ఇక్కడ క్లిక్ చేయండి