Java Language
Iterator और Iterable

परिचय

टिप्पणियों

लूप के लिए Iterable का उपयोग करना

Iterable<> इंटरफ़ेस को लागू करने वाली Iterable<> लूप के for उपयोग की जा सकती हैं। यह वास्तव में वस्तु से एक पुनरावृत्ति प्राप्त करने और सभी तत्वों को क्रमिक रूप से प्राप्त करने के लिए इसका उपयोग करने के लिए केवल वाक्यात्मक चीनी है ; यह कोड को स्पष्ट बनाता है, तेजी से अंत कम त्रुटि वाले लिखने के लिए।

public class UsingIterable {

    public static void main(String[] args) {
        List<Integer> intList = Arrays.asList(1,2,3,4,5,6,7);
        
        // List extends Collection, Collection extends Iterable
        Iterable<Integer> iterable = intList;
        
        // foreach-like loop
        for (Integer i: iterable) {
            System.out.println(i);
        }
        
        // pre java 5 way of iterating loops
        for(Iterator<Integer> i = iterable.iterator(); i.hasNext(); ) {
            Integer item = i.next();
            System.out.println(item);
        }
    }
}

कच्चे पुनरावृत्ति का उपयोग करना

फ़ॉरच लूप का उपयोग करते समय (या "लूप के लिए विस्तारित") सरल है, कभी-कभी सीधे इटरेटर का उपयोग करना फायदेमंद होता है। उदाहरण के लिए, यदि आप अल्पविराम से अलग किए गए मानों का एक समूह बनाना चाहते हैं, लेकिन अंतिम आइटम के लिए अल्पविराम नहीं चाहते हैं:

List<String> yourData = //...
Iterator<String> iterator = yourData.iterator();
while (iterator.hasNext()){
    // next() "moves" the iterator to the next entry and returns it's value.
    String entry = iterator.next();
    System.out.print(entry);
    if (iterator.hasNext()){
        // If the iterator has another element after the current one:
        System.out.print(",");
    }
}

यह isLastEntry वैरिएबल होने या लूप इंडेक्स के साथ गणना करने की तुलना में बहुत आसान और स्पष्ट है।

अपना खुद का Iterable बनाना।

किसी भी इंटरफ़ेस के साथ अपना खुद का Iterable बनाने के लिए आप बस इंटरफ़ेस में अमूर्त तरीकों को लागू करते हैं। Iterable लिए केवल एक ही है जिसे iterator() कहा जाता iterator() । लेकिन इसका वापसी प्रकार Iterator अपने आप में तीन सार विधियों वाला एक इंटरफ़ेस है। आप कुछ संग्रह से जुड़े एक पुनरावर्तक को वापस कर सकते हैं या अपना स्वयं का कस्टम कार्यान्वयन बना सकते हैं:

public static class Alphabet implements Iterable<Character> {

    @Override
    public Iterator<Character> iterator() {
        return new Iterator<Character>() {
            char letter = 'a';

            @Override
            public boolean hasNext() {
                return letter <= 'z';
            }

            @Override
            public Character next() {
                return letter++;
            }

            @Override
            public void remove() {
                throw new UnsupportedOperationException("Doesn't make sense to remove a letter");
            }
        };
    }
}

काम में लाना:

public static void main(String[] args) {
    for(char c : new Alphabet()) {
        System.out.println("c = " + c);
    }
}

नए Iterator को पहले आइटम की ओर इशारा करते हुए एक राज्य के साथ आना चाहिए, प्रत्येक अगले राज्य को इंगित करने के लिए अपने राज्य को अगले अपडेट को कॉल करता है। hasNext() यह देखने के लिए जाँच करता है कि क्या इट्रेटर अंत में है। यदि पुनरावृत्त को एक परिवर्तनीय संग्रह से जोड़ा गया था, तो वर्तमान में अंतर्निहित संग्रह से इंगित किए गए आइटम को निकालने के लिए पुनरावृत्ति का वैकल्पिक निष्कासन remove() विधि लागू की जा सकती है।

एक पुनरावृत्ति का उपयोग करने वाले तत्वों को निकालना

Iterator.remove() विधि एक वैकल्पिक विधि है जो Iterator.next() के पिछले कॉल द्वारा दिए गए तत्व को हटा देती है। उदाहरण के लिए, निम्न कोड स्ट्रिंग्स की सूची पॉप्युलेट करता है और फिर सभी रिक्त स्ट्रिंग्स को निकालता है।

List<String> names = new ArrayList<>();
names.add("name 1");
names.add("name 2");
names.add("");
names.add("name 3");
names.add("");
System.out.println("Old Size : " + names.size());
Iterator<String> it = names.iterator();
while (it.hasNext()) {
  String el = it.next();
  if (el.equals("")) {
    it.remove();
  }
}
System.out.println("New Size : " + names.size());

आउटपुट:

Old Size : 5
New Size : 3

ध्यान दें कि ऊपर दिया गया कोड एक विशिष्ट संग्रह को पुनरावृत्त करते हुए तत्वों को निकालने का सुरक्षित तरीका है। यदि इसके बजाय, आप इस तरह से संग्रह से तत्वों को निकालने का प्रयास करते हैं:

for (String el: names) {
    if (el.equals("")) {
        names.remove(el); // WRONG!
    }
}

एक विशिष्ट संग्रह (जैसे कि ArrayList ) जो पुनरावृत्त प्रदान करता है जिसमें विफल तेज इट्रेटर शब्दार्थ एक ConcurrentModificationException प्रसरण को फेंक देगा।

next() कॉल के बाद remove() विधि को केवल (एक बार) कहा जा सकता है। यदि इसे next() कॉल करने से पहले कहा जाता है next() या यदि इसे next() कॉल next() बाद दो बार कॉल किया जाता है, तो remove() कॉल एक IllegalStateException को फेंक देगा।

remove ऑपरेशन को एक वैकल्पिक ऑपरेशन के रूप में वर्णित किया गया है; यानी सभी पुनरावृत्तियाँ इसकी अनुमति नहीं देंगी। ऐसे उदाहरण जहाँ इसका समर्थन नहीं किया जाता है, इसमें अपरिवर्तनीय संग्रह के लिए पुनरावृत्तियाँ, संग्रह के केवल पढ़ने के विचार या निश्चित आकार के संग्रह शामिल हैं। यदि remove() को हटाने का समर्थन नहीं करता है, तो इसे remove() जाता है remove() कहा जाता है, यह एक UnsupportedOperationException को फेंक देगा।