మీరు పనిచేస్తుంటే a మరియు మీరు ఒక క్రమాన్ని ముద్రించాలనుకుంటున్నారని చెప్పండి, అక్కడే జావాలోని ఇటరేటర్ చిత్రంలోకి వస్తుంది. ఈ విధంగా మీరు ప్రతి పంక్తికి ముద్రణ ప్రకటనను జోడించకుండా కూడా క్రమాన్ని పొందవచ్చు. కాబట్టి, ఇటేరేటర్ గురించి తెలుసుకుందాం .
ఈ మాడ్యూల్‌లో నేను కవర్ చేయబోయే విషయాలు క్రింద ఉన్నాయి:
- ఇరేటర్ అంటే ఏమిటి?
- జావా ఇటిరేటర్ పద్ధతులు
- జావా ఇటిరేటర్ యొక్క ప్రయోజనాలు
- జావా ఇటిరేటర్ యొక్క పరిమితులు
ప్రారంభిద్దాం!
ఇరేటర్ అంటే ఏమిటి?
జావా ప్రధానంగా నాలుగు వేర్వేరు కర్సర్‌లకు మద్దతు ఇస్తుంది. అవి అవి:
- గణన
- ఇటరేటర్
- ListIterator
- స్ప్లిటర్
ఈ జావా కర్సర్లలో ప్రతిదానికి కొన్ని ప్రయోజనాలు మరియు లోపాలు ఉన్నాయి. మేము ఈ వ్యాసంలో ఇటేరేటర్‌పై దృష్టి పెడతాము.
ఇప్పుడు, జావాలో ఇటరేటర్ అంటే ఏమిటి?
ఇటరేటర్ సేకరణ ఫ్రేమ్‌వర్క్‌కు చెందిన ఇంటర్ఫేస్. ఇది సేకరణను దాటడానికి మిమ్మల్ని అనుమతిస్తుంది, డేటా మూలకాన్ని యాక్సెస్ చేస్తుంది మరియు సేకరణ యొక్క డేటా మూలకాలను తొలగిస్తుంది.
విస్తరించడం మరియు అమలు చేయడం మధ్య వ్యత్యాసం
ఇది యూనివర్సల్ ఇటెరేటర్‌గా కూడా పరిగణించబడుతుంది, ఎందుకంటే మీరు దీన్ని ఏదైనా వర్తింపజేయవచ్చు వస్తువు. ఇటిరేటర్‌ను ఉపయోగించడం ద్వారా, మీరు చదవడం మరియు తొలగించడం రెండింటినీ చేయవచ్చు. ఇది మెరుగైన సంస్కరణ గణన మూలకం యొక్క తొలగింపు-సామర్థ్యం యొక్క అదనపు కార్యాచరణలతో.
జావా ఇటిరేటర్ పద్ధతులు
జావా ఇరేటర్ మొత్తం 4 పద్ధతులను కలిగి ఉంది. వాటిని వివరంగా అర్థం చేసుకుందాం.
| పద్ధతులు | వివరణ |
|---|---|
| forEachRemaining (వినియోగం) | ఇది అన్ని మూలకాలను ప్రాసెస్ చేసే వరకు మరియు ప్రతి మూలకంపై చర్యలను చేస్తుంది. చర్య ద్వారా మినహాయింపు విసిరే వరకు. |
| hasNext () | ఇది రాబడి పునరావృత సమయంలో అధిక సంఖ్యలో అంశాలు ఎదురైతే నిజమైన విలువ. |
| తరువాత() | ఇది రాబడి పునరావృత సమయంలో తదుపరి పేర్కొన్న మూలకం. |
| తొలగించు () | ఈ పద్ధతి rప్రస్తుత మూలకాన్ని తొలగిస్తుంది. విసురుతాడు చట్టవిరుద్ధ స్టేట్ ఎక్సెప్షన్ తొలగించడానికి () కాల్ చేయడానికి ప్రయత్నం చేస్తే, అది తదుపరి () కు కాల్‌కు ముందు కాదు. |
| బూలియన్ hasNext () | పునరుక్తికి మరిన్ని అంశాలు ఉంటే ఇది నిజం అవుతుంది. |
ఉదాహరణ:
తరగతి విధానం {పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) శ్రేణి జాబితా జాబితా = క్రొత్త శ్రేణి జాబితా () list.add ('E') list.add ('D') list.add ('U') list.add ('R ') list.add (' E ') list.add (' K ') list.add (' A ') // జాబితాను దాటడానికి ఇటిరేటర్ ఇటిరేటర్ iterator = list.iterator () System.out.println (' జాబితా అంశాలు : ') అయితే (iterator.hasNext ()) System.out.print (iterator.next () +' ') System.out.println ()}}అవుట్పుట్: EDUREKA
జావాలోని ListIterator ని పరిశీలిద్దాం.
జావాలో ListIterator
జావాలో xml ఫైళ్ళను అన్వయించడం
ListIterator జావాలో ఒక ఇటిరేటర్, ఇది వినియోగదారులను రెండు దిశలలో కలెక్షన్ ద్వారా ప్రయాణించడానికి అనుమతిస్తుంది. ఇది క్రింది పద్ధతులను కలిగి ఉంది:
| పద్ధతులు | విధానం & వివరణ |
|---|---|
| శూన్య జోడింపు (ఆబ్జెక్ట్ ఆబ్జెక్ట్) | తదుపరి కాల్ ద్వారా తదుపరి () కు తిరిగి వచ్చే మూలకం ముందు జాబితాలో ఆబ్జెక్ట్ చొప్పిస్తుంది. |
| బూలియన్ hasNext () | తదుపరి మూలకం ఉంటే నిజం అవుతుంది. లేకపోతే, తప్పుడు తిరిగి వస్తుంది. |
| బూలియన్ hasPrevious () | మునుపటి మూలకం ఉంటే నిజం అవుతుంది. లేకపోతే, తప్పుడు తిరిగి వస్తుంది. |
| ఆబ్జెక్ట్ తదుపరి () | తదుపరి మూలకాన్ని అందిస్తుంది. తదుపరి మూలకం లేకపోతే NoSuchElementException విసిరివేయబడుతుంది. |
| int nextIndex () | తదుపరి మూలకం యొక్క సూచికను చూపుతుంది. తదుపరి మూలకం లేకపోతే, జాబితా యొక్క పరిమాణాన్ని తిరిగి ఇస్తుంది. |
| ఆబ్జెక్ట్ మునుపటి () | మునుపటి మూలకాన్ని అందిస్తుంది. మునుపటి మూలకం లేకపోతే NoSuchElementException విసిరివేయబడుతుంది. |
| పూర్ణాంక మునుపటి ఇండెక్స్ () | మునుపటి మూలకం యొక్క సూచికను చూపుతుంది. మునుపటి మూలకం లేకపోతే, -1 తిరిగి ఇస్తుంది. |
| void remove () | జాబితా నుండి ప్రస్తుత మూలకాన్ని తొలగిస్తుంది. తదుపరి () లేదా మునుపటి () ప్రారంభించబడటానికి ముందు తొలగించు () అని పిలువబడితే చట్టవిరుద్ధ స్టేట్ ఎక్సెప్షన్ విసిరివేయబడుతుంది. |
| శూన్య సెట్ (ఆబ్జెక్ట్ ఆబ్జెక్ట్) | ప్రస్తుత మూలకానికి ఆబ్జెక్ట్‌ని కేటాయిస్తుంది. తదుపరి () లేదా మునుపటి () కు కాల్ ద్వారా చివరిగా తిరిగి వచ్చిన మూలకం ఇది. |
ఉదాహరణ:
పబ్లిక్ క్లాస్ జాబితాలు {పబ్లిక్ స్టాటిక్ శూన్య మెయిన్ (స్ట్రింగ్ అర్గ్స్ []) {// శ్రేణి జాబితాను సృష్టించండి అర్రేలిస్ట్ అల్ = కొత్త అర్రేలిస్ట్ () // శ్రేణి జాబితాకు మూలకాలను జోడించండి al.add ('E') al.add ('D ') al.add (' U ') al.add (' R ') al.add (' E ') al.add (' K ') al.add (' A ') // యొక్క విషయాలను ప్రదర్శించడానికి iterator ని ఉపయోగించండి al System.out.print ('అల్ యొక్క అసలు విషయాలు:') ఇటిరేటర్ itr = al.iterator () అయితే (itr.hasNext ()) {ఆబ్జెక్ట్ ఎలిమెంట్ = itr.next () System.out.print (ఎలిమెంట్ + '' )} System.out.println () // పునరావృతమయ్యే వస్తువులను సవరించండి ListIterator litr = al.listIterator () అయితే (litr.hasNext ()) {ఆబ్జెక్ట్ మూలకం = litr.next () litr.set (మూలకం + '+') . System.out.print ('అల్ యొక్క సవరించిన విషయాలు:') itr = al.iterator () అయితే (itr.hasNext ()) {ఆబ్జెక్ట్ ఎలిమెంట్ = itr.next () System.out.print (ఎలిమెంట్ + '') . System.out.println () // ఇప్పుడు, జాబితాను వెనుకకు ప్రదర్శించండి System.out.print ('సవరించిన జాబితా వెనుకకు:') అయితే (litr.hasPrevious ()) {ఆబ్జెక్ట్ ఎలిమెంట్ = litr.previous () System.out. ముద్రణ (మూలకం + '')} System.out.println ()}}అవుట్పుట్:
అసలుఅల్ యొక్క విషయాలు:E D U R E K A.
సవరించబడిందిఅల్ యొక్క విషయాలు:IS+డి+యు+ఆర్+IS+TO+ అ +
సవరించబడిందివెనుకకు జాబితా చేయండి:TO+TO+IS+ఆర్+యు+డి+ మరియు +
జావాలో తేదీ మార్పిడికి స్ట్రింగ్
ఇప్పుడు, జావాలోని ఈ ఇరేటర్ ఇంటర్ఫేస్ యొక్క ప్రయోజనాలు మరియు పరిమితులను పరిశీలిద్దాం.
జావాలో ఇటరేటర్ యొక్క ప్రయోజనాలు
జావాలోని ఇటరేటర్ కింది ప్రయోజనాలు ఉన్నాయి.
- మీరు ఏ కలెక్షన్ క్లాస్ కోసం ఈ ఇరేటర్లను ఉపయోగించవచ్చు.
- జావాలోని ఇటరేటర్ రెండింటికి మద్దతు ఇస్తుంది చదవండి అలాగే తొలగించండి కార్యకలాపాలు.
- మీరు ఉపయోగిస్తుంటే లూప్ కోసం నీవల్ల కాదు సేకరణను నవీకరించండి (జోడించండి / తీసివేయండి) అయితే ఇటిరేటర్ సహాయంతో మీరు సేకరణను సులభంగా నవీకరించవచ్చు.
- ఇది కలెక్షన్ API కోసం యూనివర్సల్ కర్సర్.
- పద్ధతి పేర్లు చాలా సులభం మరియు ఉపయోగించడానికి చాలా సులభం.
జావాలో ఇటరేటర్ యొక్క పరిమితులు
జావాలోని ఇటరేటర్లకు ఈ క్రింది లోపాలు ఉన్నాయి:
- మీరు ఫార్వర్డ్ డైరెక్షన్ ఇటరేషన్ మాత్రమే చేయగలరు, అంటే యూని-డైరెక్షనల్ ఇటిరేటర్.
- క్రొత్త మూలకం యొక్క పున ment స్థాపన మరియు చేరికకు ఇటిరేటర్ మద్దతు లేదు.
- ListIterator అత్యంత శక్తివంతమైన ఇటరేటర్ కాని ఇది జాబితా అమలు చేయబడిన తరగతులకు మాత్రమే వర్తిస్తుంది. కనుక ఇది యూనివర్సల్ ఇరేటర్ కాదు.
- మీరు CRUD ఆపరేషన్లను ఉపయోగించినప్పుడు, ఇది సృష్టించు మరియు నవీకరించు ఆపరేషన్లకు మద్దతు ఇవ్వదు.
- మీరు దీన్ని స్ప్లిటేరేటర్‌తో పోల్చినప్పుడు, మూలకాలను సమాంతరంగా మళ్ళించటానికి ఇది మిమ్మల్ని అనుమతించదు. దీని అర్థం ఇది సీక్వెన్షియల్ పునరావృతానికి మాత్రమే మద్దతు ఇస్తుంది.
- పెద్ద మొత్తంలో డేటాను మళ్ళించడానికి ఇది మంచి పనితీరుకు మద్దతు ఇవ్వదు.
ఇది జావాలో ఇటరేటర్ ఎలా పనిచేస్తుందో తెలుసుకున్న ఈ వ్యాసం చివరకి మనలను తీసుకువస్తుంది. ఈ ట్యుటోరియల్‌లో మీతో పంచుకున్న అన్ని విషయాలతో మీరు స్పష్టంగా ఉన్నారని ఆశిస్తున్నాము.
“జావాలో ఇటేరేటర్” పై ఈ కథనాన్ని మీరు కనుగొంటే, చూడండి ప్రపంచవ్యాప్తంగా 250,000 కంటే ఎక్కువ సంతృప్తికరమైన అభ్యాసకుల నెట్‌వర్క్‌తో విశ్వసనీయ ఆన్‌లైన్ లెర్నింగ్ సంస్థ.
మీ ప్రయాణంలో అడుగడుగునా మీకు సహాయం చేయడానికి మేము ఇక్కడ ఉన్నాము, వీటితో పాటు, మేము జావా డెవలపర్‌గా ఉండాలనుకునే విద్యార్థులు మరియు నిపుణుల కోసం రూపొందించిన ఒక పాఠ్యాంశంతో ముందుకు వచ్చాము. ఈ కోర్సు మీకు జావా ప్రోగ్రామింగ్‌లోకి రావడానికి మరియు హైబర్నేట్ & స్ప్రింగ్ వంటి వివిధ జావా ఫ్రేమ్‌వర్క్‌లతో పాటు కోర్ మరియు అడ్వాన్స్‌డ్ జావా కాన్సెప్ట్‌ల కోసం మీకు శిక్షణ ఇవ్వడానికి రూపొందించబడింది.
మీకు ఏవైనా ప్రశ్నలు వస్తే, “జావాలోని ఇటేరేటర్” యొక్క వ్యాఖ్యల విభాగంలో మీ ప్రశ్నలన్నింటినీ అడగడానికి సంకోచించకండి మరియు మా బృందం సమాధానం ఇవ్వడానికి సంతోషిస్తుంది.