ఈ బ్లాగ్ జావాలో ListIterator “next()” పద్ధతిని వర్తింపజేయడం గురించి వివరిస్తుంది.
Java ListIterator “next()” పద్ధతిని ఎలా ఉపయోగించాలి?
లిస్ట్ఇటరేటర్ ' తరువాత() జాబితా ద్వారా మళ్ళించడం ద్వారా అందించిన జాబితాలో తదుపరి మూలకాన్ని ఇవ్వడానికి ” పద్ధతి ఉపయోగించబడుతుంది.
వాక్యనిర్మాణం
ప్రజా X తదుపరి ( )
ఈ వాక్యనిర్మాణంలో, ' X ” ఇంటర్‌ఫేస్ ఇటరేటర్‌ని సూచిస్తుంది.
గమనిక: ఈ పద్ధతి తిరిగి ఇస్తుంది ' NoSuchElementException పునరావృతంలో ఏ అంశాలు మిగిలి ఉండకపోతే.
'లోని అన్ని తరగతులను యాక్సెస్ చేయడానికి ముందుగా క్రింది ప్యాకేజీలను చేర్చండి java.util 'ప్యాకేజీ మరియు పని' ఇటరేటర్ ”, వరుసగా:
దిగుమతి java.util.* ;దిగుమతి java.util.Iterator ;
ఉదాహరణ 1: జావాలో లిస్ట్ఇటరేటర్ “తదుపరి()” పద్ధతిని వర్తింపజేయడం
ఈ ఉదాహరణలో, జాబితా ద్వారా పునరావృతం చేయడానికి ListIterator “next()” పద్ధతిని అన్వయించవచ్చు:
ప్రజా తరగతి తరువాత {
ప్రజా స్థిరమైన శూన్యం ప్రధాన ( స్ట్రింగ్ [ ] వాదనలు ) {
జాబితా < స్ట్రింగ్ > జాబితా = కొత్త అర్రేలిస్ట్ < స్ట్రింగ్ > ( ) ;
జాబితా. జోడించు ( 'జావా' ) ;
జాబితా. జోడించు ( 'ప్రోగ్రామింగ్' ) ;
ఇటరేటర్ < స్ట్రింగ్ > ఇటర్ = జాబితా. పునరావృతం చేసేవాడు ( ) ;
వ్యవస్థ . బయటకు . println ( ఇటర్. తరువాత ( ) ) ;
వ్యవస్థ . బయటకు . println ( ఇటర్. తరువాత ( ) ) ;
వ్యవస్థ . బయటకు . println ( ఇటర్. తరువాత ( ) ) ;
} }
ఈ కోడ్ బ్లాక్‌లో:
- ముందుగా, ఒక 'ని సృష్టించండి అర్రేలిస్ట్ ' యొక్క ' స్ట్రింగ్ ” రకం.
- ఆ తరువాత, వర్తించు ' జోడించు() ” జాబితాకు పేర్కొన్న స్ట్రింగ్ విలువలను జోడించే పద్ధతి.
- ఇప్పుడు, అర్రేలిస్ట్ నుండి మూలకాలు '' ద్వారా యాక్సెస్ చేయబడతాయి Iterator.next() ”యాక్సెసర్ పద్ధతి మూడుసార్లు వర్తించబడింది.
- జాబితా రెండు మూలకాలను కలిగి ఉన్నందున, మూడవసారి అభ్యర్థించిన మూలకం ఉనికిలో లేదు మరియు కనుక ' NoSuchElementException ” తిరిగి వస్తుంది.
అవుట్‌పుట్
ఇక్కడ, జాబితా పూర్తిగా పునరుద్ఘాటించిన తర్వాత చర్చించబడిన లోపం ఎదుర్కొన్నట్లు చూడవచ్చు. ఇది కలిగి ఉన్న మూలకాలు రెండు మరియు పద్ధతి అంటే, 'తదుపరి()' మూడుసార్లు వర్తించబడుతుంది.
ఉదాహరణ 2: ListIterator “next()” మరియు “hasNext()” పద్ధతులను వర్తింపజేయడం
ఈ ఉదాహరణ ఇటరేటర్ ఉపయోగించి చర్చించిన లోపాన్ని ఎదుర్కుంటుంది ' ఉంది తదుపరి() ” పద్ధతి. ఈ పద్దతి మొదటగా ఇటరేటర్‌లో మరిన్ని అంశాలు ఉంటే విశ్లేషిస్తుంది, ఆపై వాటిని '' ద్వారా యాక్సెస్ చేస్తుంది. తరువాత() ” పద్ధతి, తద్వారా లోపాన్ని నిర్వహించడం:
ప్రజా తరగతి తరువాత {ప్రజా స్థిరమైన శూన్యం ప్రధాన ( స్ట్రింగ్ [ ] వాదనలు ) {
జాబితా < స్ట్రింగ్ > జాబితా = కొత్త అర్రేలిస్ట్ < స్ట్రింగ్ > ( ) ;
జాబితా. జోడించు ( 'జావా' ) ;
జాబితా. జోడించు ( 'ప్రోగ్రామింగ్' ) ;
ఇటరేటర్ < స్ట్రింగ్ > ఇటర్ = జాబితా. పునరావృతం చేసేవాడు ( ) ;
అయితే ( ఇటర్. తదుపరి ఉంది ( ) ) {
వ్యవస్థ . బయటకు . println ( ఇటర్. తరువాత ( ) ) ;
}
వ్యవస్థ . బయటకు . println ( 'ఎగ్జిక్యూషన్ కొనసాగించు!' ) ;
} }
ఈ కోడ్ బ్లాక్‌లో, క్రింద ఇవ్వబడిన దశలను అమలు చేయండి:
- 'ని సృష్టించడానికి చర్చించిన విధానాలను పునరావృతం చేయండి అర్రేలిస్ట్ ” మరియు దానికి ఎలిమెంట్స్ జోడించడం.
- ఇప్పుడు, 'లో అయితే 'లూప్, వర్తించు' ఉంది తదుపరి() ”ఇటరేటర్‌తో పద్ధతి. తదుపరి మూలకం సంభవించినప్పుడు, అది (మూలకం) '' ద్వారా ప్రారంభించబడుతుంది. తరువాత() ” పద్ధతి.
- లేకుంటే, కోడ్ అమలు కొనసాగుతుందని, తద్వారా గతంలో ఎదుర్కొన్న పరిమితి/లోపాన్ని తొలగించడం ద్వారా రెండో స్టేట్‌మెంట్ తిరిగి ఇవ్వబడుతుంది.
అవుట్‌పుట్
ఈ అవుట్‌పుట్‌లో, నిర్దిష్ట లోపం తగిన విధంగా నిర్వహించబడుతుందని గమనించవచ్చు.
ముగింపు
ది ' తరువాత() 'లిస్ట్ఇటరేటర్' ఇంటర్‌ఫేస్ యొక్క పద్ధతి జాబితా ద్వారా మళ్ళించడం ద్వారా అందించిన జాబితాలో తదుపరి మూలకాన్ని ఇస్తుంది మరియు 'ని తిరిగి ఇస్తుంది NoSuchElementException పునరావృతంలో ఏ అంశాలు మిగిలి ఉండకపోతే. అయితే, ఎదుర్కొన్న మినహాయింపు ఇటరేటర్ ద్వారా తొలగించబడుతుంది ' ఉంది తదుపరి() ” పద్ధతి. ఈ బ్లాగ్ జావాలో ఇటరేటర్ “తదుపరి()” పద్ధతిని ఉపయోగించడం మరియు అమలు చేయడం గురించి చర్చించింది.