पुनरावर्तक और पुनरावर्तनीय और उनका उपयोग कैसे करें के बीच क्या अंतर है?

Question

मैं जावा में नया हूं और मैं वास्तव में पुनरावर्तक और पुनरावर्तक के साथ उलझन में हूं। क्या कोई मुझे समझा सकता है और कुछ उदाहरण दे सकता है?

Answer 1

एक Iterable तत्वों की एक श्रृंखला का एक सरल प्रतिनिधित्व है जिसे पुनरावृत्त किया जा सकता है। इसमें कोई पुनरावृत्ति स्थिति नहीं है जैसे कि "वर्तमान तत्व"। इसके बजाए, इसमें एक विधि है जो Iterator उत्पन्न करती है।

एक Iterator पुनरावृत्ति स्थिति वाला वस्तु है। यह आपको hasNext() का उपयोग करके अधिक तत्वों की जांच करने देता है और next() का उपयोग करके अगले तत्व (यदि कोई हो) पर जाता है।

आमतौर पर, Iterable किसी भीएस के किसी भी संख्या का उत्पादन करने में सक्षम होना चाहिए।

Answer 2

यदि कोई संग्रह पुनरावर्तनीय है, तो इसे एक पुनरावर्तक का उपयोग करके पुनरावृत्त किया जा सकता है (और इसके परिणामस्वरूप प्रत्येक पाश के लिए उपयोग किया जा सकता है।) इटेटरेटर वास्तविक वस्तु है जो संग्रह के माध्यम से पुनरावृत्त हो जाएगी।

Answer 3

Iterable का एक कार्यान्वयन एक ही की एक Iterator प्रदान करता है:

public interface Iterable<T> 
{ 
    Iterator<T> iterator(); 
} 

एक इटरेटर डेटा का एक संग्रह के माध्यम से काम विशेषाधिकारों के बिना पाश करने के लिए कुछ की अनुमति के एक सरल तरीका है (हालांकि हटाने की क्षमता के साथ) ।

public interface Iterator<E> 
{ 
    boolean hasNext(); 
    E next(); 
    void remove(); 
} 

Javadoc देखें।

Answer 4

इटरटेबल इंटरफेस को कार्यान्वित करने से ऑब्जेक्ट को "foreach" कथन का लक्ष्य बनने की अनुमति मिलती है।

class SomeClass implements Iterable<String> {} 

class Main 
{ 
    public void method() 
    { 
    SomeClass someClass = new SomeClass(); 
    ..... 

    for(String s : someClass) { 
    //do something 
    } 
    } 
} 

इटरेटर एक इंटरफेस है, जिसमें तत्वों के पुनरावृत्ति के लिए कार्यान्वयन है। Iterable एक इंटरफ़ेस है जो इटरेटर प्रदान करता है।

Answer 5

सबसे महत्वपूर्ण विचार यह है कि प्रश्न में आइटम को एक से अधिक बार पार करने में सक्षम होना चाहिए या नहीं। ऐसा इसलिए है क्योंकि आप फिर से इटरेटर() को कॉल करके एक इटरबल को रिवाइंड कर सकते हैं, लेकिन इटरेटर को रिवाइंड करने का कोई तरीका नहीं है।

Answer 6

Iterable: एक कक्षा जिसे फिर से चालू किया जा सकता है। यही वह है, जिसकी धारणा है कि "मुझे पहली चीज मिलें, अब अगली चीज़, और इसी तरह, जब तक हम बाहर नहीं निकलते।"

इटरेटर: एक वर्ग जो पुनरावृत्त पर पुनरावृत्ति का प्रबंधन करता है। यही है, यह ट्रैक करता है कि हम वर्तमान पुनरावृत्ति में कहां हैं, और यह जानता है कि अगला तत्व क्या है और इसे कैसे प्राप्त किया जाए।

ऑब्जेक्ट को पुन: प्रयोज्य बनाने के लिए इसे Iterator ऑब्जेक्ट को उत्सर्जित करने की आवश्यकता है। इस अनुबंध को लागू करने के लिए, इटेरेबल इंटरफ़ेस का उपयोग किया जाना है। इसमें इटरेटर() नामक एक विधि है और यह इटरेटर लौटाती है। इसलिए, इटरटेबल लागू करने वाली कोई भी कक्षा एक इटरेटर लौटाएगी।

public interface Collection<E> extends Iterable<E> {} 

उदाहरण के लिए कोई संग्रह लें। एक संग्रह एक इंटरफेस है जो तत्वों की श्रृंखला के लिए कंटेनर का प्रतिनिधित्व करता है। ArrayList, वेक्टर जैसे संग्रह जैसे संग्रह और इतने इटरेटर।

Iterable का एक लाभ है, जब आप Iterable लागू करते हैं तो उन ऑब्जेक्ट के लिए समर्थन मिलता है: प्रत्येक लूप वाक्यविन्यास।

Answer 7

प्रश्न: Iterable और Iterator के बीच अंतर?
उत्तर:

iterable: यह foreach पाश से संबंधित है
इटरेटर: है संग्रह

से संबंधित है foreach पाश का लक्ष्य तत्व iterable हो shouble।
हम इटरेटर का उपयोग कर सकते संग्रह से एक के बाद वस्तु पाने के लिए

java.lang पैकेज में Iterable वर्तमान
इटरेटर java.util पैकेज में मौजूद

केवल एक ही विधि इटरेटर()
शामिल होता है तीन विधि hasNext(), अगले(), हटाने()

1,5 संस्करण में प्रस्तुत
1.2 संस्करण में प्रस्तुत

Answer 8

ColinD और Seeker उत्तरों के अतिरिक्त।

सरल शब्दों में, Iterable और इटरेटर जावा के संग्रह फ्रेमवर्क में प्रदान की दोनों इंटरफेस है।

Iterable

एक वर्ग Iterable इंटरफ़ेस को लागू करने के लिए अगर यह एक -प्रत्येक अपने संग्रह से अधिक पुनरावृति करने के लिए लूप करने की है है। हालांकि, प्रत्येक लूप के लिए केवल अगली दिशा में संग्रह के माध्यम से चक्र के लिए उपयोग किया जा सकता है और आप इस संग्रह में तत्वों को संशोधित करने में सक्षम नहीं होंगे। लेकिन, यदि आप चाहते हैं कि तत्व डेटा को पढ़ना है, तो यह बहुत आसान है और जावा लैम्ब्डा अभिव्यक्ति के लिए धन्यवाद यह अक्सर एक लाइनर होता है। उदाहरण के लिए:

iterableElements.forEach (x -> System.out.println(x)); 

इटरेटर

इस इंटरफ़ेस एक संग्रह से अधिक पुनरावृति करने के लिए, प्राप्त करने और उसके तत्वों को दूर करने के लिए सक्षम बनाता। संग्रह कक्षाओं में से प्रत्येक इटरेटर() विधि प्रदान करता है जो संग्रह की शुरुआत में एक पुनरावर्तक देता है। इस इंटरफ़ेस का लाभ पुन: प्रयोज्य है कि इस इंटरफ़ेस के साथ आप संग्रह में तत्व जोड़, संशोधित या हटा सकते हैं। लेकिन, तत्वों तक पहुंचने से थोड़ा अधिक कोड की आवश्यकता होती है।

for (Iterator i = c.iterator(); i.hasNext();) { 
     Element e = i.next(); //Get the element 
     System.out.println(e); //access or modify the element 
} 

---

सूत्रों का कहना है: उदाहरण के लिए:

1. Java Doc Iterable
2. Java Doc Iterator

Answer 9

मूल रूप से बोल रहा है, उन दोनों बहुत बारीकी से एक दूसरे से जुड़े हुए हैं।

इटरेटर पर विचार करें)) एक अंतरफलक जो हमें hasNext (जैसे कुछ अपरिभाषित तरीकों की मदद से एक संग्रह के माध्यम से traversing में मदद करता है, अगले (हो सकता है और दूर करने के लिए()

दूसरा पहलू पर, Iterable एक और इंटरफ़ेस है, जो, यदि कक्षा द्वारा कार्यान्वित किया जाता है तो कक्षा को अक्षय होने के लिए मजबूर किया जाता है और प्रत्येक निर्माण के लिए एक लक्ष्य है। इसमें इटरेटर() नामक केवल एक विधि है जो इटरेटर इंटरफेस से ही आती है।

जब कोई संग्रह पुनरावर्तनीय होता है, तो इसे एक पुनरावर्तक का उपयोग करके पुनरावृत्त किया जा सकता है।

समझ के लिए इन पर जाएँ:

iterable:http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/6-b14/java/lang/Iterable.java

iteratorhttp://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/6-b14/java/util/Iterator.java

Answer 10

एक उदाहरण 10 सेब होने पर विचार करें। जब यह इटरटेबल लागू करता है, तो यह प्रत्येक सेब को 1 से 10 तक बक्से में डालने जैसा होता है और एक इटरेटर लौटाता है जिसका उपयोग नेविगेट करने के लिए किया जा सकता है।

इटरेटर लागू करने से, हम किसी भी सेब के आगे स्थित बॉक्स आदि

तो लागू करने .. iterable इटरेटर कार्यान्वित करने की आवश्यकता है, हालांकि नेविगेट करने के लिए उसके तत्वों नेविगेट करने के लिए एक iterator देता

Answer 11

के रूप में सेब प्राप्त कर सकते हैं, here समझाया गया, "Iterable" को foreach लूप में उपयोग करने में सक्षम होने के लिए पेश किया गया था। लागू करने वाली कक्षा Iterable इंटरफ़ेस को फिर से चालू किया जा सकता है।

इटरेटर कक्षा है जो Iterable पर पुनरावृत्ति प्रबंधित करती है। यह एक ऐसी स्थिति को बनाए रखता है जहां हम वर्तमान पुनरावृत्ति में हैं, और यह जानता है कि अगला तत्व क्या है और इसे कैसे प्राप्त किया जाए।

Answer 12

मैं मदद करने के लिए आप बेहतर ढंग से समझने में एक उदाहरण के रूप में विशेष रूप से ArrayList के बारे में सवाल का जवाब होगा ..

1. Iterable इंटरफेस इसके उपवर्गों बलों सार विधि लागू करने के लिए 'इटरेटर()'।

public interface Iterable { 
    ... 
    abstract Iterator<T> iterator(); //Returns an 'Iterator'(not iterator) over elements of type T. 
    ... 
} 

1. इटरेटर इंटरफेस इसके उपवर्गों बलों सार विधि 'hasNext()' और लागू करने के लिए 'अगले()'।

public interface Iterator { 
    ... 
    abstract boolean hasNext(); //Returns true if the iteration has more elements. 
    abstract E next();   //Returns the next element in the iteration. 
    ... 
} 

1. ArrayList लागू करता है सूची, सूची संग्रह को लागू करता है और संग्रह Iterable लागू करता है .. है, तो आप

   की तरह संबंध देख सकते हैं 'Iterable < - संग्रह < - सूची < - ArrayList'

। और इटेबल, संग्रह और सूची बस अमूर्त विधि 'इटेटर()' घोषित करें और केवल ऐरेलिस्ट इसे लागू करता है।

4. मैं अधिक विस्तृत जानकारी के लिए 'iterator()' विधि के साथ ArrayList स्रोत कोड दिखाने जा रहा हूं।

'इटरेटर()' विधि कक्षा 'इट्र' का एक ऑब्जेक्ट देता है जो 'इटरेटर' लागू करता है।

public class ArrayList<E> ... implements List<E>, ... 
{ 
    ... 
    public Iterator<E> iterator() { 
       return new Itr(); 
    } 


    private class Itr implements Iterator<E> { 
      ... 

      public boolean hasNext() { 
       return cursor != size; 
      } 
      @SuppressWarnings("unchecked") 
      public E next() { 
       checkForComodification(); 
       int i = cursor; 
       if (i >= size) 
        throw new NoSuchElementException(); 
       Object[] elementData = ArrayList.this.elementData; 
       if (i >= elementData.length) 
        throw new ConcurrentModificationException(); 
       cursor = i + 1; 
       return (E) elementData[lastRet = i]; 
      } 
      ... 
    } 
} 

1. कुछ अन्य तरीकों या वर्गों इटरेटर (Itr) का इस्तेमाल कर रही के माध्यम से ArrayList की तरह संग्रह के तत्वों पुनरावृति होगी।

यहां एक साधारण उदाहरण है।

public static void main(String[] args) { 

    List<String> list = new ArrayList<>(); 
    list.add("a"); 
    list.add("b"); 
    list.add("c"); 
    list.add("d"); 
    list.add("e"); 
    list.add("f"); 

    Iterator<String> iterator = list.iterator(); 
    while (iterator.hasNext()) { 
     String string = iterator.next(); 
     System.out.println(string); 
    } 
} 

अब, यह स्पष्ट है? :)