पुनरावृत्ती करणारे

"हाय, अमिगो!"

"हाय, एली!"

"आज मी तुम्हाला पुनरावृत्ती करणाऱ्यांबद्दल सांगू इच्छितो."

"Iterators चा शोध व्यावहारिकरित्या संग्रहाप्रमाणेच लावला गेला होता. संग्रहाचा मुख्य उद्देश घटक संग्रहित करणे आहे आणि पुनरावृत्तीचा मुख्य उद्देश हा घटक एक एक करून पुनर्प्राप्त करणे आहे."

"घटकांचा संच मिळवण्यात इतके अवघड काय आहे?"

"प्रथम, काही संग्रहातील घटक, जसे की सेट, स्थापित ऑर्डर नसतात आणि/किंवा क्रम सतत बदलत असतो."

"दुसरे, काही डेटा स्ट्रक्चर्स अतिशय गुंतागुंतीच्या पद्धतीने वस्तू संग्रहित करू शकतात: वेगवेगळ्या गटांमध्ये, याद्या इ. दुसऱ्या शब्दांत, सर्व घटकांना क्रमाने सुपूर्द करणे हे एक क्षुल्लक काम असेल."

"तिसरे, संग्रह बदलतात. समजा तुम्ही संग्रहातील संपूर्ण सामग्री प्रदर्शित करण्याचे ठरवले, परंतु आउटपुटच्या मध्यभागी JVM दुसर्‍या थ्रेडवर स्विच करते जे संग्रहातील अर्धे घटक बदलते. त्यामुळे आउटपुटऐवजी, तुम्हाला मिळेल कोणास ठाऊक काय."

"हम्म..."

"परंतु! या तंतोतंत अशा प्रकारच्या समस्या आहेत ज्या एक पुनरावृत्तीकर्ता सोडवू शकतो. पुनरावृत्ती करणारा हा संग्रहातील एक विशेष वस्तू आहे ज्याला, एकीकडे, त्याच्या सर्व खाजगी डेटामध्ये प्रवेश असतो आणि त्याची अंतर्गत रचना माहित असते आणि दुसरीकडे , सार्वजनिक इटरेटर इंटरफेस लागू करते, जे प्रत्येकाला त्याच्यासोबत कसे कार्य करायचे हे कळू देते. "

"काही इटरेटर्समध्ये अंतर्गत अॅरे असते ज्यामध्ये इटरेटर तयार केल्यावर संग्रहातील सर्व घटक कॉपी केले जातात. हे सुनिश्चित करते की संग्रहातील त्यानंतरचे कोणतेही बदल घटकांच्या संख्येवर किंवा क्रमावर परिणाम करणार नाहीत."

"मला वाटते की प्रत्येकासाठी काम करत असताना तुम्हाला हे लक्षात आले आहे . तुम्ही एकाच वेळी कलेक्शन लूप करू शकत नाही आणि त्यातून घटक काढून टाकू शकत नाही. हे सर्व तंतोतंत इटरेटरच्या कार्य करण्याच्या पद्धतीमुळे आहे."

"समवर्ती लायब्ररीमध्ये जोडलेल्या नवीन संग्रहांमध्ये, ही समस्या दूर करण्यासाठी इटरेटर पुन्हा तयार केला आहे."

"मी तुम्हाला आठवण करून देतो की पुनरावृत्तीकर्ता कसे कार्य करते."

"जावामध्ये एक विशेष इटरेटर इंटरफेस आहे. त्याच्या पद्धती येथे आहेत:"

"एक पुनरावृत्ती करणारा तुम्हाला एका संग्रहातील सर्व घटक क्रमशः मिळवू देतो. एखाद्या पुनरावृत्तीचा इनपुटस्ट्रीम सारखा विचार करणे अधिक तर्कसंगत आहे - त्यात सर्व डेटा आहे, परंतु त्याचे कार्य अनुक्रमे आउटपुट करणे आहे."

"   पुढील () पद्धत संग्रहातील पुढील घटक परत करते."

" आणखी काही घटक आहेत का हे तपासण्यासाठी hasNext () पद्धत वापरली जाते."

"आणि काढा () वर्तमान घटक काढून टाकते."

"काही प्रश्न?"

"पद्धतींना अशी विचित्र नावे का आहेत? isEmpty() आणि getNextElement() का नाही?"

"त्याला जास्त अर्थ नाही का?"

"हे अधिक अर्थपूर्ण होईल, परंतु नावे C++ भाषेतून आली आहेत, जिथे पुनरावृत्ती करणारे पूर्वी दिसू लागले."

"मी बघतो. पुढे चालू ठेवूया."

"Iterator व्यतिरिक्त, Iterable इंटरफेस देखील आहे, जो पुनरावृत्त्यांना समर्थन देणार्‍या सर्व संग्रहांद्वारे कार्यान्वित करणे आवश्यक आहे. त्याची एकच पद्धत आहे:"

"तुम्ही या पद्धतीचा वापर कोणत्याही कलेक्शनवर इटरेटर ऑब्जेक्ट मिळवण्यासाठी त्याच्या घटकांमधून करू शकता. चला ट्रीसेटमधील सर्व घटकांवर जाऊ या :"

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

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

"अशा प्रकारचा इटरेटर वापरणे फार सोयीचे नाही — तेथे खूप जास्त अनावश्यक आणि स्पष्ट कोड आहे. Java मध्ये प्रत्येक लूप दिसल्यावर परिस्थिती अधिक सोपी झाली ."

"आता हा कोड अधिक संक्षिप्त आणि वाचनीय आहे:"

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 .

"त्यांच्या अंमलबजावणीची पर्वा न करता, याद्या घटकांचा क्रम कायम ठेवतात, ज्यामुळे त्यांच्यासह पुनरावृत्त्याद्वारे थोडे अधिक सोयीस्करपणे कार्य करणे शक्य होते."

" ListIterator <E> इंटरफेसच्या पद्धती येथे आहेत :"

"दुसर्‍या शब्दात, येथे आपण पुढे आणि मागे दोन्ही जाऊ शकतो. आणि इतर काही लहान वैशिष्ट्ये आहेत."

"बरं, ती मनोरंजक सामग्री आहे. ती कुठे वापरली जाते?"

"समजा तुम्हाला लिंक केलेल्या सूचीवर मागे-पुढे जायचे आहे. गेट ऑपरेशन खूपच हळू असेल, परंतु पुढील() ऑपरेशन खूप वेगवान असेल."

"हम्म. तू मला पटवून दिलेस. मी ते लक्षात ठेवेन."

"धन्यवाद, एली!"