साक्षात्कार: संग्रहों के संग्रह के लिए एक पुनरावर्तक डिजाइन करें

Question

जावा में संग्रहों के संग्रह के लिए एक पुनरावर्तक डिज़ाइन करें। इटरेटर को घोंसले को छिपाना चाहिए, जिससे आप सभी संग्रहों से जुड़े सभी तत्वों को फिर से सक्रिय कर सकते हैं जैसे कि आप एक संग्रह के साथ काम कर रहे थे

Answer 1

यहां एक संभावित कार्यान्वयन है। ध्यान दें कि मैं निकालें() लागू नहीं किया गया छोड़ दिया:

public class MultiIterator <T> implements Iterator<T>{ 

    private Iterator<? extends Collection<T>> it; 
    private Iterator<T> innerIt; 
    private T next; 
    private boolean hasNext = true; 

    public MultiIterator(Collection<? extends Collection<T>> collections) { 
     it = collections.iterator();  
     prepareNext(); 
    } 

    private void prepareNext() { 
     do { 
      if (innerIt == null || !innerIt.hasNext()) { 
       if (!it.hasNext()) { 
        hasNext = false; 
        return; 
       } else 
        innerIt = it.next().iterator(); 
      } 
     } while (!innerIt.hasNext()); 

     next = innerIt.next(); 
    } 

    @Override 
    public boolean hasNext() { 
     return hasNext; 
    } 

    @Override 
    public T next() { 
     if (!hasNext) 
      throw new NoSuchElementException(); 
     T res = next; 
     prepareNext(); 
     return res; 
    } 

    @Override 
    public void remove() { 
     //TODO 
    } 

} 

Answer 2

सबसे पहले, java.util में इटरेटर के कार्यान्वयन पर नज़र डालें। LinkedList

http://www.docjar.com/html/api/java/util/LinkedList.java.html

वहां से अपने काम है सिर्फ एक इटरेटर कि खाते में तथ्य यह है कि यह संग्रह से अधिक पुनरावृत्ति है लेता लागू आसान।

सम्मान।

Answer 3

अगर सभी आप के साथ काम करना है जावा इटरेटर है: जो सिर्फ hasNext(), अगले() और (निकालने के लिए), मैं समझ तुम चारों ओर जाना है यह।

इसे संसाधित करें क्योंकि आप 2 डी सरणी को संसाधित करेंगे, यानी बाहरी और आंतरिक पाश के साथ, क्योंकि उनके पास "व्यवस्था" है लेकिन अलग-अलग डेटाटाइप है। जैसे ही आप प्रक्रिया करते हैं, आप उन्हें एक नए संग्रह में स्थानांतरित करते हैं।

तो शायद एक निजी विधि:

private void convertToSingleCollection() 
    { 


     while("column") 
     { 
      //convert the "column" to an arra 


      for("Row") 
      { 
      //add to newCollection here 
      } 

      //remove the processed column from CollectionOFcollection 
     } 
    } 
    //call the above method in your constructor 


    public iterator<T> Iterator() 
    { 
     newCollection.iterator(); 
    } 

    public boolean hasNext() 
    { 
     return Iterator().hasNext() 
    } 

    public T next() 
    { 
     if(!hasNext()) 
     { 
     //exception message or message 
     } 
     else 
      //return "next" 
    } 

अंत

मुझे आशा है कि इस मदद करता है। मुझे लगता है कि इसे हल करने के अन्य तरीके होना चाहिए।

Answer 4

this post में आप दो कार्यान्वयन देख सकते हैं, केवल (मामूली) अंतर यह है कि यह संग्रहों के संग्रह के बजाय इटेटरेटर का पुनरावर्तक लेता है।

यह अंतर आवश्यकता राउंड रोबिन फैशन में तत्वों (एक आवश्यकता है कि इस प्रश्न में ओपी द्वारा अनुरोध नहीं किया गया था) पुनरावृत्ति करने के साथ संयुक्त एक सूची में iterators को कॉपी करने की भूमि के ऊपर कहते हैं।

पहले दृष्टिकोण आलसी है: यह एक तत्व केवल जब इस तत्व का अनुरोध किया जाता पुनरावृति जाएगा, 'मूल्य' हम भुगतान किया है कि कोड अधिक जटिल है, क्योंकि यह अधिक किनारे मामलों को संभालने के लिए की जरूरत है:

import java.util.Iterator; 
import java.util.LinkedList; 
import java.util.List; 
import java.util.NoSuchElementException;  

public class MultiIterator<E> implements Iterator { 

    List<Iterator<E>> iterators = new LinkedList<>(); 
    Iterator<E> current = null; 

    public MultiIterator(Iterator<Iterator<E>> iterator) { 
     // copy the iterators into a list 
     while (iterator.hasNext()) { 
      iterators.add(iterator.next()); 
     } 
    } 

    @Override 
    public boolean hasNext() { 
     boolean result = false; 
     if (iterators.isEmpty() && (current == null || !current.hasNext())) { 
      return false; 
     } 

     if (current == null) { 
      current = iterators.remove(0); 
     } 

     while (!current.hasNext() && !iterators.isEmpty()) { 
      current = iterators.remove(0); 
     } 

     if (current.hasNext()) { 
      result = true; 
     } 
     return result; 
    } 

    @Override 
    public E next() { 
     if (current == null) { 
      try { 
       current = iterators.remove(0); 
      } catch (IndexOutOfBoundsException e) { 
       throw new NoSuchElementException(); 
      } 
     } 
     E result = current.next(); // if this method was called without checking 'hasNext' this line might raise NoSuchElementException which is fine 
     iterators.add(current); 
     current = iterators.remove(0); 
     return result; 
    } 

    // test 
    public static void main(String[] args) { 
     List<Integer> a = new LinkedList<>(); 
     a.add(1); 
     a.add(7); 
     a.add(13); 
     a.add(17); 
     List<Integer> b = new LinkedList<>(); 
     b.add(2); 
     b.add(8); 
     b.add(14); 
     b.add(18); 
     List<Integer> c = new LinkedList<>(); 
     c.add(3); 
     c.add(9); 
     List<Integer> d = new LinkedList<>(); 
     d.add(4); 
     d.add(10); 
     d.add(15); 
     List<Integer> e = new LinkedList<>(); 
     e.add(5); 
     e.add(11); 
     List<Integer> f = new LinkedList<>(); 
     f.add(6); 
     f.add(12); 
     f.add(16); 
     f.add(19); 
     List<Iterator<Integer>> iterators = new LinkedList<>(); 
     iterators.add(a.iterator()); 
     iterators.add(b.iterator()); 
     iterators.add(c.iterator()); 
     iterators.add(d.iterator()); 
     iterators.add(e.iterator()); 
     iterators.add(f.iterator()); 
     MultiIterator<Integer> it = new MultiIterator<>(iterators.iterator()); 
     while (it.hasNext()) { 
      System.out.print(it.next() + ","); // prints: 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19, 
     } 
    } 
} 

और दूसरा ('लालची' का अनुरोध किया आदेश में सभी iterators से सभी तत्वों की सूची में कॉपी करने और उस सूची को पुनरावर्तक लौटने):

import java.util.Iterator; 
import java.util.LinkedList; 
import java.util.List; 

public class MultiIterator<E> { 

    Iterator<Iterator<E>> iterator = null; 
    List<E> elements = new LinkedList<>(); 

    private MultiIterator(Iterator<Iterator<E>> iterator) { 
     this.iterator = iterator; 
    } 

    private void copyElementsInOrder() { 
     List<Iterator<E>> iterators = new LinkedList<>(); 
     // copy the iterators into a list 
     while (iterator.hasNext()) { 
      iterators.add(iterator.next()); 
     } 
     // go over the list, round-robin, and grab one 
     // element from each sub-iterator and add it to *elements* 
     // empty sub-iterators will get dropped off the list 
     while (!iterators.isEmpty()) { 
      Iterator<E> subIterator = iterators.remove(0); 
      if (subIterator.hasNext()) { 
       elements.add(subIterator.next()); 
       iterators.add(subIterator); 
      } 
     } 
    } 

    public static <E> Iterator<E> iterator(Iterator<Iterator<E>> iterator) { 
     MultiIterator<E> instance = new MultiIterator<>(iterator); 
     instance.copyElementsInOrder(); 
     return instance.elements.iterator(); 
    } 

    // test 
    public static void main(String[] args) { 
     List<Integer> a = new LinkedList<>(); 
     a.add(1); 
     a.add(7); 
     a.add(13); 
     a.add(17); 
     List<Integer> b = new LinkedList<>(); 
     b.add(2); 
     b.add(8); 
     b.add(14); 
     b.add(18); 
     List<Integer> c = new LinkedList<>(); 
     c.add(3); 
     c.add(9); 
     List<Integer> d = new LinkedList<>(); 
     d.add(4); 
     d.add(10); 
     d.add(15); 
     List<Integer> e = new LinkedList<>(); 
     e.add(5); 
     e.add(11); 
     List<Integer> f = new LinkedList<>(); 
     f.add(6); 
     f.add(12); 
     f.add(16); 
     f.add(19); 
     List<Iterator<Integer>> iterators = new LinkedList<>(); 
     iterators.add(a.iterator()); 
     iterators.add(b.iterator()); 
     iterators.add(c.iterator()); 
     iterators.add(d.iterator()); 
     iterators.add(e.iterator()); 
     iterators.add(f.iterator()); 
     Iterator<Integer> it = MultiIterator.<Integer>iterator(iterators.iterator()); 
     while (it.hasNext()) { 
      System.out.print(it.next() + ","); // prints: 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19, 
     } 
    } 
} 

मैं एक साधारण 'परीक्षण' शामिल मल्टीइटरेटर का उपयोग करने के तरीके को दिखाने के लिए कोड, यह हमेशा नहीं होता है तुच्छ (जेनेरिक के उपयोग की वजह से) जैसा कि आप लाइन पर देख सकते हैं:

Iterator<Integer> it = MultiIterator.<Integer>iterator(iterators.iterator());