जावा, लेकिन एकाधिक इटरेटर प्रकार?

Question

मेरे पास कक्षा Polygon है जिस पर मैं दो पुनरावृत्तियों को कार्यान्वित करना चाहता हूं: एक बार सभी तत्वों (वैकल्पिक क्रम में शिखर और किनारों) के माध्यम से चलाने के लिए, और दूसरा इन्हें infinitum (चक्रीय रूप से) चलाने के लिए चलाता है।

प्रत्येक उपयोग दृष्टिकोण के लिए, मेरा अनुमान है कि मैं केवल उपरोक्त में से एक को डिफ़ॉल्ट इटरेटर का उपयोग करने में सक्षम होने वाला हूं जिसका उपयोग Iterable.iterator() के कार्यान्वयन के माध्यम से किया जा सकता है। क्या ये सही है? या क्या कोई तरीका है जिसके लिए मैं प्रत्येक के लिए उपयोग कर सकता हूं?

public Iterable<String> eachOnce() { 
    List<String> allResults = new ArrayList<String>(); 
    // fill list 
    return allResults; 
} 

public Iterable<String> eachCyclic() { 
    return new Iterable<String>() { 

     public Iterator<String> iterator() { 
      return new Iterator<String>() { 

       public boolean hasNext() { 
        return true; 
       } 

       public String next() { 
        // TODO implement 
        return null; 
       } 

       public void remove() { 
        // do nothing 
       } 
      }; 

     } 
    }; 
} 

इस स्ट्रिंग की एक सूची के साथ सिर्फ एक उदाहरण है, बस अनुकूलन:

Answer 1

बस दो अलग Iterators, प्रत्येक मामले के लिए वापस लौटाते समय दो तरीकों जोड़ें।

for (Polygon p : polygons) { } 

के बजाय

बस का उपयोग

for (Polygon p : polygons.eachOnce()) { } 

या चक्रीय संस्करण

Answer 2

एक उत्तर मुझे लगता है कि पहले से ही प्रस्तुत की तुलना में बेहतर है एक विधि है कि एक चक्रीय में किसी भी Iterable बदल जाता है एक।

public class IterableUtils { 
    public static class CyclicIterator<T> implements Iterator<T> { 
    private final Iterable<T> inner; 
    private Iterator<T> currentIter; 
    public CyclicIterator(Iterable<T> inner) { 
     this.inner = inner; 
    } 
    public boolean hasNext() { 
     if (currentIter == null || !currentIter.hasNext()) { 
     currentIter = inner.iterator(); 
     } 
     return currentIter.hasNext(); 
    } 
    public T next() { 
     if (currentIter == null || !currentIter.hasNext()) { 
     currentIter = inner.iterator(); 
     } 
     return currentIter.next(); 
    } 
    public void remove() { 
     currentIter.remove(); 
    } 
    } 
    public static <T> Iterable<T> cycle(final Iterable<T> i) { 
    return new Iterable<T>() { 
     public Iterator<T> iterator() { return new CyclicIterator<T>(i); } 
    }; 
    } 
} 

तो फिर तुम सिर्फ बहुभुज वर्ग में एकल इटरेटर विधि को लागू करने और

for (Element e: polygon) { 
    ... 
} 

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

के लिए

कर सकते हैं (तत्व ई: चक्र (बहुभुज)) { । .. }

अंतहीन रूप से पुनरावृत्त करने के लिए। बोनस के रूप में, चक्र संशोधक किसी भी पुनरावर्तनीय पर लागू किया जा सकता है।