Ist es möglich, Iteratoren in Java zusammenzuführen?

Könnte man erstellen Sie Ihre eigene Implementierung der Iterator - Schnittstelle, die iteriert über die Iteratoren:

public class IteratorOfIterators implements Iterator {
    private final List<Iterator> iterators;

    public IteratorOfIterators(List<Iterator> iterators) {
        this.iterators = iterators;
    }

    public IteratorOfIterators(Iterator... iterators) {
        this.iterators = Arrays.asList(iterators);
    }


    public boolean hasNext() { /* implementation */ }

    public Object next() { /* implementation */ }

    public void remove() { /* implementation */ }
}

(Ich habe nicht Hinzugefügt, Generika zu den Iterator für die Kürze.) Die Umsetzung ist nicht allzu schwer, aber ist nicht das trivialste, die Sie benötigen, um zu verfolgen, welche Iterator Sie derzeit Durchlaufen, und ruft next() müssen Sie Durchlaufen, so weit wie möglich durch die Iteratoren, bis Sie eine hasNext() zurückgibt true oder können Sie schlagen das Ende der letzten iterator.

ich bin mir nicht bewusst jede Implementierung, die bereits für diese.

Update:

Ich habe bis-zum Andrew Duffy ' s Antwort - keine Notwendigkeit, das Rad neu zu erfinden. Ich wirklich brauchen, um sich in die Guave in mehr Tiefe.

Die ich Hinzugefügt habe, einen anderen Konstruktor für eine variable Anzahl von Argumenten - fast immer off-topic, wie die Klasse aufgebaut ist, ist hier nicht wirklich von Interesse, nur das Konzept, wie es funktioniert.

InformationsquelleAutor der Antwort Noel M

Ich habe nicht geschrieben, Java-code in eine Weile, und das hat mich neugierig um, ob ich noch "got it".

Erster Versuch:

import java.util.Iterator;
import java.util.Arrays; /* For sample code */

public class IteratorIterator<T> implements Iterator<T> {
    private final Iterator<T> is[];
    private int current;

    public IteratorIterator(Iterator<T>... iterators)
    {
            is = iterators;
            current = 0;
    }

    public boolean hasNext() {
            while ( current < is.length && !is[current].hasNext() )
                    current++;

            return current < is.length;
    }

    public T next() {
            while ( current < is.length && !is[current].hasNext() )
                    current++;

            return is[current].next();
    }

    public void remove() { /* not implemented */ }

    /* Sample use */
    public static void main(String... args)
    {
            Iterator<Integer> a = Arrays.asList(1,2,3,4).iterator();
            Iterator<Integer> b = Arrays.asList(10,11,12).iterator();
            Iterator<Integer> c = Arrays.asList(99, 98, 97).iterator();

            Iterator<Integer> ii = new IteratorIterator<Integer>(a,b,c);

            while ( ii.hasNext() )
                    System.out.println(ii.next());
    }
}

Du könnte natürlich weitere Collection-Klassen eher als ein reines array + index Zähler, aber das fühlt sich wirklich ein bisschen sauberer als die alternative. Oder bin ich einfach nur voreingenommen schreiben meist C in diesen Tagen?

Sowieso, dort gehen Sie. Die Antwort auf deine Frage ist "ja, wahrscheinlich".

InformationsquelleAutor der Antwort Christoffer

einen iterator stammt AUS einer Sammlung oder eine Gruppe.

warum nicht die Methode verwenden, die bereits verfügbar

Collection.addAll(Collection c);

und dann erstellen Sie Ihre iterator vom letzten Objekt.

auf diese Weise werden Ihre iterator iteriert alle Inhalte der Sammlung.

InformationsquelleAutor der Antwort

Können Sie meine version einer ausziehbaren iterator. Es verwendet einen double-ended-queue von Iteratoren, die für mich Sinn macht:

import java.util.Deque;
import java.util.Iterator;
import java.util.concurrent.ConcurrentLinkedDeque;

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

    public Deque<Iterator<T>> its = new ConcurrentLinkedDeque<Iterator<T>>();

    public ExtendableIterator() {

    }

    public ExtendableIterator(Iterator<T> it) {
        this();
        this.extend(it);
    }

    @Override
    public boolean hasNext() {
        //this is true since we never hold empty iterators
        return !its.isEmpty() && its.peekLast().hasNext();
    }

    @Override
    public T next() {
        T next = its.peekFirst().next();
        if (!its.peekFirst().hasNext()) {
            its.removeFirst();
        }
        return next;
    }

    public void extend(Iterator<T> it) {
        if (it.hasNext()) {
            its.addLast(it);
        }
    }
}

InformationsquelleAutor der Antwort Reut Sharabani

Können Sie versuchen, ConcatIterator von Cactoos:

Iterator<String> names = new ConcatIterator<>(
  Arrays.asList("Sarah", "Mary").iterator(),
  Arrays.asList("Jeff", "Johnny").iterator(),
);

Überprüfen Sie auch ConcatIterabledie verkettet Iterables.

InformationsquelleAutor der Antwort yegor256

jeder Iterator Objekt besitzt eigenen Speicherplatz (Adresse), so kann man nicht einfach "mischen". es sei denn, Sie verlängern iterator Klasse und schreiben Sie Ihre eigene Implementierung gibt.

Wenn Sie Umgang mit den gleiche Anzahl von Objekten in beiden Iteratoren eine alternative Lösung wäre die Verarbeitung von zwei Iteratoren in einer Schleife wie diese :

   while (iterator1.hasNext() && iterator2.hasNext()) {
      //code
    }

InformationsquelleAutor der Antwort Youssef