జావాలో ప్రోగ్రామింగ్ చేస్తున్నప్పుడు, బహుళ ఫంక్షనాలిటీలను అనుబంధించాల్సిన అవసరం ఉంటుంది. ఉదాహరణకు, చెట్లతో పని చేయడం లేదా ప్రాధాన్యత ఆధారిత లక్షణాలతో వ్యవహరించడం. అటువంటి పరిస్థితులలో, ' సమూహ ఉచ్చులు ” జావాలో డెవలపర్ లింక్ చేయబడిన ఫీచర్లను కూడబెట్టడానికి మరియు విలీనం చేయడానికి మరియు కోడ్ ఫంక్షనాలిటీలను సమర్థవంతంగా క్రమబద్ధీకరించడానికి వీలు కల్పిస్తుంది.
ఈ వ్యాసం జావాలో “నెస్టెడ్ లూప్‌లను” ఉపయోగించడం మరియు అమలు చేయడం గురించి చర్చిస్తుంది.
జావాలో 'నెస్టెడ్ లూప్స్' అంటే ఏమిటి?
ఎ' సమూహ లూప్ జావాలో ”అవుటర్ లూప్ యొక్క లూప్ బాడీలో ఉండే అంతర్గత లూప్‌కు అనుగుణంగా ఉంటుంది. వివిధ లింక్డ్ ఫంక్షనాలిటీలను అనుబంధించడానికి ఈ లూప్‌లను వివిధ సందర్భాల్లో అన్వయించవచ్చు.
ఉదాహరణ 1: జావాలో పూర్ణాంకాలపై నెస్టెడ్ లూప్‌లను వర్తింపజేయడం
ఈ ఉదాహరణలో, ప్రతి ఇతర పునరావృత విలువలలో నిర్దిష్ట విలువలను కూడబెట్టడానికి సమూహ లూప్‌లు ఉపయోగించబడతాయి:
int id = 2 ;
int వయస్సు = 10 ;
కోసం ( int i = 0 ; i < = id ; i++ ) {
System.out.println ( 'ID:' + i ) ;
కోసం ( int j = 5 ; j < = వయస్సు; j++ ) {
System.out.println ( 'వయస్సు:' + జె ) ;
} }
పై కోడ్ లైన్లలో:
- ముందుగా, రెండు పూర్ణాంకాల విలువలను ప్రారంభించండి.
- ఆ తరువాత, వర్తించు ' కోసం ”పూర్వం ప్రారంభించిన పూర్ణాంకంతో మళ్ళించడానికి మరియు దానిని ప్రదర్శించడానికి లూప్.
- ఇప్పుడు, సమూహాన్ని వర్తింపజేయి ' కోసం ” లూప్ తరువాతి పూర్ణాంకం ద్వారా వ్యక్తిగతంగా మళ్ళించబడుతుంది మరియు దానిని కన్సోల్‌లో లాగ్ చేయండి.
- ఇది ప్రతి పూర్వ పూర్ణాంకంలో చివరి పూర్ణాంకాలలో ప్రతి ఒక్కటి సంచితం అవుతుంది.
గమనిక: సమూహ (తరువాతి) లూప్ బాహ్య లూప్ పరిధిలో సంచితం చేయబడింది.
అవుట్‌పుట్
ఈ అవుట్‌పుట్‌లో, గూడు తగిన విధంగా జరిగిందని చూడవచ్చు.
ఉదాహరణ 2: జావాలోని శ్రేణులపై నెస్టెడ్ లూప్‌లను వర్తింపజేయడం
ఈ ప్రత్యేక ఉదాహరణలో, ''తో పాటు మళ్ళించడానికి సమూహ లూప్‌లను అమలు చేయవచ్చు. స్ట్రింగ్ ”శ్రేణులు:
స్ట్రింగ్ శ్రేణి1 [ ] = { 'హ్యారీ' , 'డేవిడ్' , 'జాక్' } ;స్ట్రింగ్ అర్రే2 [ ] = { 'ది ఏంజిల్స్' , 'లండన్' , 'బీజింగ్' } ;
కోసం ( int i = 0 ;i < శ్రేణి1.పొడవు;i++ ) {
System.out.println ( శ్రేణి1 [ i ] + ' \n ' ) ;
కోసం ( int j = 0 ;జె < శ్రేణి2.పొడవు;j++ ) {
System.out.println ( శ్రేణి2 [ j ] + ' \n ' ) ;
} }
పై కోడ్ బ్లాక్‌లో:
- ' పేరుతో రెండు స్ట్రింగ్ శ్రేణులను ప్రకటించండి శ్రేణి1 'మరియు' శ్రేణి2 ” పేర్కొన్న విలువలను కలిగి ఉంటుంది.
- ఇప్పుడు, వర్తించు ' కోసం 'పూర్వ స్ట్రింగ్ శ్రేణి ద్వారా పునరావృతం చేయడానికి లూప్.
- అదేవిధంగా, మునుపటి లూప్‌లోని తరువాతి నెస్టెడ్ లూప్ ద్వారా మళ్ళించండి.
- ఇది ప్రతి బాహ్య లూప్ మూలకంలో ప్రతి సమూహ శ్రేణి మూలకాన్ని అదేవిధంగా ప్రదర్శిస్తుంది.
అవుట్‌పుట్
ఈ ఫలితం నుండి, సమూహ లూప్‌లోని ప్రతి స్ట్రింగ్ విలువలు బాహ్య లూప్ విలువలకు వ్యతిరేకంగా ప్రదర్శించబడతాయని విశ్లేషించవచ్చు.
ఉదాహరణ 3: జావాలో నమూనాను ముద్రించడానికి నెస్టెడ్ లూప్‌లను వర్తింపజేయడం
ఈ ఉదాహరణలో, ''ని ముద్రించడానికి సమూహ లూప్‌లను అమలు చేయవచ్చు సగం పిరమిడ్ నమూనా ”:
పూర్ణాంక వరుసలు, రంగులు, మొత్తం వరుసలు = 3 ;కోసం ( వరుసలు = 0 ; వరుసలు < మొత్తం వరుసలు; అడ్డు వరుసలు ++ ) {
కోసం ( cols = 0 ; cols < = వరుసలు; cols++ ) {
System.out.print ( '*' ) ;
}
System.out.println ( ) ;
}
ఈ కోడ్ బ్లాక్‌లో, దిగువ అందించిన దశలను వర్తింపజేయండి:
- ముందుగా, పేర్కొన్న విలువలను వరుసగా పేర్కొనండి మరియు ప్రారంభించండి.
- ఇప్పుడు, వర్తించు ' కోసం ” పిరమిడ్ వరుసలకు సంబంధించిన లూప్.
- సమూహ ' కోసం ” లూప్ పిరమిడ్ నిలువు వరుసలను సూచిస్తుంది.
- ఈ లూప్‌లో, ప్రింట్ చేయడానికి పేర్కొన్న నమూనాను ప్రింట్ చేయండి, తద్వారా నమూనాను తయారు చేయండి.
- అల్గోరిథం: ప్రతి అడ్డు వరుసకు, ప్రతి పునరావృతం వద్ద నిలువు వరుస పరిమితిని మించకుండా సమూహ నిలువు వరుస ముద్రించబడుతుంది.
- చివరగా, ఖాళీ ' println() ” పద్ధతి వరుసగా నమూనాను పిరమిడ్‌గా ముద్రిస్తుంది.
అవుట్‌పుట్
పిరమిడ్ నమూనా స్పష్టంగా తగిన విధంగా ముద్రించబడిందని ఈ అవుట్‌పుట్ చూపిస్తుంది.
ముగింపు
ఎ' సమూహ లూప్ ” జావాలో లోపలి లూప్ బాహ్య లూప్‌పై ఆధారపడి ఉండేలా బాహ్య లూప్ యొక్క లూప్ బాడీలో కనిపించే అంతర్గత లూప్‌కు అనుగుణంగా ఉంటుంది. ఈ లూప్‌లు ప్రారంభించబడిన విలువలు మరియు శ్రేణులపై లేదా వరుసగా నమూనాను సృష్టించడానికి వర్తించవచ్చు. ఈ బ్లాగ్ జావాలో నెస్టెడ్ లూప్‌ల అమలు గురించి చర్చించింది.