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

"హాయ్, అమిగో!"

"హాయ్, ఎల్లీ!"

"ఈరోజు నేను మీకు పునరావృత్తులు గురించి చెప్పాలనుకుంటున్నాను."

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

"మూలకాల సమితిని పొందడంలో చాలా కష్టం ఏమిటి?"

"మొదట, సెట్ వంటి కొన్ని సేకరణలలోని మూలకాలు ఏర్పాటు చేయబడిన క్రమాన్ని కలిగి ఉండవు మరియు/లేదా క్రమం నిరంతరం మారుతూ ఉంటుంది."

"రెండవది, కొన్ని డేటా స్ట్రక్చర్‌లు ఆబ్జెక్ట్‌లను చాలా క్లిష్టంగా నిల్వ చేయవచ్చు: వివిధ సమూహాలు, జాబితాలు మొదలైనవి. మరో మాటలో చెప్పాలంటే, అన్ని ఎలిమెంట్‌లను క్రమపద్ధతిలో అందజేయడం అనేది చిన్నవిషయం కాని పని."

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

"హ్మ్..."

"కానీ! ఇవి ఖచ్చితంగా ఇటరేటర్ పరిష్కరించగల సమస్యల విధమైనవి. ఇటరేటర్ అనేది సేకరణలోని ఒక ప్రత్యేక వస్తువు, ఇది ఒక వైపు, దాని మొత్తం ప్రైవేట్ డేటాకు ప్రాప్యతను కలిగి ఉంటుంది మరియు దాని అంతర్గత నిర్మాణాన్ని తెలుసుకుంటుంది మరియు మరోవైపు , పబ్లిక్ ఇటరేటర్ ఇంటర్‌ఫేస్‌ను అమలు చేస్తుంది, దానితో ఎలా పని చేయాలో ప్రతి ఒక్కరికీ తెలియజేస్తుంది. "

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

" ప్రతిదానితో పని చేస్తున్నప్పుడు మీరు దీనిని ఎదుర్కొన్నారని నేను భావిస్తున్నాను . మీరు సేకరణపై ఏకకాలంలో లూప్ చేయలేరు మరియు దాని నుండి ఎలిమెంట్‌లను తీసివేయలేరు. ఇటరేటర్ పని చేసే విధానం వల్లనే ఇదంతా జరిగింది."

"కాకరెన్సీ లైబ్రరీకి జోడించిన కొత్త సేకరణలలో, ఈ సమస్యను తొలగించడానికి ఇటరేటర్ మళ్లీ పని చేయబడింది."

"ఇటరేటర్ ఎలా పనిచేస్తుందో నేను మీకు గుర్తు చేస్తాను."

"జావాకు ప్రత్యేక ఇటరేటర్ ఇంటర్‌ఫేస్ ఉంది. దాని పద్ధతులు ఇక్కడ ఉన్నాయి:"

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

"   తదుపరి () పద్ధతి సేకరణలో తదుపరి మూలకాన్ని అందిస్తుంది."

" ఇంకేమైనా అంశాలు ఉన్నాయో లేదో తనిఖీ చేయడానికి hasNext () పద్ధతి ఉపయోగించబడుతుంది."

"మరియు తీసివేయి () ప్రస్తుత మూలకాన్ని తొలగిస్తుంది."

"ఏవైనా ప్రశ్నలు వున్నాయ?"

"పద్ధతులకు అలాంటి వింత పేర్లు ఎందుకు ఉన్నాయి? isEmpty() మరియు getNextElement() ఎందుకు కాదు?"

"ఇంకా అర్ధం కాలేదా?"

"ఇది మరింత అర్ధవంతంగా ఉంటుంది, కానీ పేర్లు C++ భాష నుండి వచ్చాయి, ఇక్కడ ఇటరేటర్లు ముందుగా కనిపించాయి."

"చూసాను. కంటిన్యూ చేద్దాం."

"ఇటరేటర్‌తో పాటు, ఇటరబుల్ ఇంటర్‌ఫేస్ కూడా ఉంది, ఇది ఇటరేటర్‌లకు మద్దతు ఇచ్చే అన్ని సేకరణల ద్వారా తప్పనిసరిగా అమలు చేయబడాలి. దీనికి ఒకే పద్ధతి ఉంది:"

"ఇటరేటర్ ఆబ్జెక్ట్ దాని మూలకాల ద్వారా నడవడానికి మీరు ఏ సేకరణలోనైనా ఈ పద్ధతిని ఉపయోగించవచ్చు. ట్రీసెట్‌లోని అన్ని మూలకాలపై నడుద్దాం :"

TreeSet<String> set = new TreeSet<String>();
Iterator<String> iterator = set.iterator();

while (iterator.hasNext())
{
 String item = iterator.next();
 System.out.println(item);
}

"ఇటువంటి ఇటరేటర్‌ని ఉపయోగించడం చాలా అనుకూలమైనది కాదు - చాలా నిరుపయోగంగా మరియు స్పష్టమైన కోడ్ ఉంది. జావాలో ప్రతి లూప్ కనిపించినప్పుడు పరిస్థితి సరళంగా మారింది ."

"ఇప్పుడు ఈ కోడ్ చాలా కాంపాక్ట్ మరియు చదవగలిగేది:"

TreeSet<String> set = new TreeSet<String>();
Iterator<String> iterator = set.iterator();

while (iterator.hasNext())
{
 String item = iterator.next();
 System.out.println(item);
}

TreeSet<String> set = new TreeSet<String>();

for(String item : set)
{
 System.out.println(item);
}

"ఇది ఒకటే కోడ్! ఇటరేటర్ రెండు సందర్భాలలో ఉపయోగించబడుతుంది."

" ప్రతి లూప్‌లో దాని ఉపయోగం దాగి ఉంది . కుడి వైపున ఉన్న కోడ్‌లో ఎరుపు రంగు వచనం లేదని గమనించండి. ఇటరేటర్ యొక్క ఉపయోగం పూర్తిగా దాచబడింది."

" ఇటరేటర్‌లకు మద్దతిచ్చే ఏదైనా ఆబ్జెక్ట్‌ల కోసం ప్రతి లూప్ ఉపయోగించబడుతుంది. మరో మాటలో చెప్పాలంటే, మీరు మీ స్వంత తరగతిని వ్రాయవచ్చు, దానికి ఇటరేటర్ () పద్ధతిని జోడించవచ్చు మరియు ప్రతి నిర్మాణంలో దాని వస్తువులను ఉపయోగించవచ్చు."

"వావ్! వాస్తవానికి, నా స్వంత సేకరణలు మరియు పునరావృత్తులు వ్రాయడానికి నేను ఆసక్తిగా లేను, కానీ అవకాశం ఇంకా ఉత్సాహంగా ఉంది. నేను దానిని నోట్ చేస్తాను."

అదనంగా, దాని స్వంత ఇంటర్‌ఫేస్‌ను కలిగి ఉన్న మరొక ప్రసిద్ధ రకం ఇటరేటర్ కూడా ఉంది. నేను జాబితాల కోసం ఇటరేటర్ గురించి మాట్లాడుతున్నాను, అంటే ListIterator .

"వాటి అమలుతో సంబంధం లేకుండా, జాబితాలు మూలకాల క్రమాన్ని నిర్వహిస్తాయి, ఇది ఒక ఇటరేటర్ ద్వారా వాటితో మరింత సౌకర్యవంతంగా పని చేస్తుంది."

" లిస్ట్ఇటరేటర్ <E> ఇంటర్ఫేస్ యొక్క పద్ధతులు ఇక్కడ ఉన్నాయి :"

"మరో మాటలో చెప్పాలంటే, ఇక్కడ మనం ముందుకు మరియు వెనుకకు కదలవచ్చు. ఇంకా కొన్ని ఇతర చిన్న లక్షణాలు ఉన్నాయి."

"సరే, అది ఆసక్తికరమైన విషయం. ఇది ఎక్కడ ఉపయోగించబడింది?"

"మీరు లింక్ చేయబడిన జాబితాలో ముందుకు వెనుకకు తరలించాలనుకుంటున్నారని అనుకుందాం. గెట్ ఆపరేషన్ చాలా నెమ్మదిగా ఉంటుంది, కానీ తదుపరి() ఆపరేషన్ చాలా వేగంగా ఉంటుంది."

"హ్మ్. నువ్వు నన్ను ఒప్పించావు. మనసులో పెట్టుకుంటాను."

"ధన్యవాదాలు, ఎల్లీ!"