Java für jeden, aber mehrere Iterator-Typen?

Question

Ich habe eine Klasse Polygon, auf der ich zwei Iteratoren implementieren möchte: einen durch alle Elemente (Ecken und Kanten in alternierender Reihenfolge) nur einmal durchlaufen, und ein anderes durch sie ad infinitum (zyklisch) durchlaufen.

Von einem für jeden Verwendungszweck, meine Annahme ist, dass ich nur in der Lage sein, eine der oben genannten der Standard-Iterator, der mit for-each, über die Implementierung von Iterable.iterator() verwendet werden kann. Ist das richtig? Oder gibt es einen Weg, den ich für beide nutzen könnte?

Answer 1

Fügen Sie einfach zwei Methoden zwei verschiedene Iteratoren, für jeden Fall einer Rückkehr:

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 
       } 
      }; 

     } 
    }; 
} 

Dieses mit einer Liste von Strings ist nur ein Beispiel, nur anpassen.

Statt

for (Polygon p : polygons) { } 

verwenden nur

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

oder die zyklische Ausgabe

Answer 2

Eine Antwort, die ich denke, ist besser als die bereits vorgestellten ist ein Verfahren, das jede Iterable in einem zyklischen dreht ein.

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); } 
    }; 
    } 
} 

Dann können Sie einfach die einzelnen Iteratormethode in der Polygon-Klasse implementieren und verwenden

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

einmal zu durchlaufen und

für (Element e: Zyklus (Polygon)) { . .. }

um endlos zu iterieren. Als Bonus kann der Zyklusmodifikator auf jedes iterierbare Element angewendet werden.