Wie verwandle ich eine Java-Aufzählung in einen Stream?

Ich habe eine Drittanbieter-Bibliothek, die mir eine gibt Enumeration<String>. Ich möchte mit dieser Aufzählung lazily als Java - 8 arbeiten Stream, rufen Dinge wie filter, mapund flatMapauf sie.

Gibt es eine vorhandene Bibliothek, in der dies enthalten ist? Ich beziehe mich bereits auf Guava und Apache Commons. Wenn also einer von beiden die Lösung hat, wäre das ideal.

Alternativ, was ist der beste / einfachste Weg, um aus einer Zeit Enumerationeine StreamFaulheit zu machen?

Diese Antwort bietet bereits eine Lösung, die Streamaus einem Enumeration:

 public static <T> Stream<T> enumerationAsStream(Enumeration<T> e) {
     return StreamSupport.stream(
         Spliterators.spliteratorUnknownSize(
             new Iterator<T>() {
                 public T next() {
                     return e.nextElement();
                 }
                 public boolean hasNext() {
                     return e.hasMoreElements();
                 }
             },
             Spliterator.ORDERED), false);
 }

Es sollte betont werden , dass die resultierende Stream ist wie jede andere als faul Stream, da es keine Produkte verarbeiten , bevor das Terminal Aktion begonnen wurde , und wenn die Terminalbetrieb Kurzschluss ist, wird es nur so viele Punkte wie nötig wiederholen.

Dennoch gibt es Raum für Verbesserungen. Ich würde immer eine forEachRemainingMethode hinzufügen , wenn es eine einfache Möglichkeit gibt, alle Elemente zu verarbeiten. Diese Methode wird von der StreamImplementierung für die meisten nicht kurzgeschlossenen Operationen aufgerufen :

public static <T> Stream<T> enumerationAsStream(Enumeration<T> e) {
    return StreamSupport.stream(
        Spliterators.spliteratorUnknownSize(
            new Iterator<T>() {
                public T next() {
                    return e.nextElement();
                }
                public boolean hasNext() {
                    return e.hasMoreElements();
                }
                public void forEachRemaining(Consumer<? super T> action) {
                    while(e.hasMoreElements()) action.accept(e.nextElement());
                }
            },
            Spliterator.ORDERED), false);
}

Der obige Code ist jedoch ein Opfer des IteratorAntipatterns "Verwenden, weil es so vertraut ist". Das erstellte Iteratorwird in eine Implementierung der neuen SpliteratorSchnittstelle eingebunden und bietet keinen Vorteil gegenüber der Spliteratordirekten Implementierung :

public static <T> Stream<T> enumerationAsStream(Enumeration<T> e) {
    return StreamSupport.stream(
        new Spliterators.AbstractSpliterator<T>(Long.MAX_VALUE, Spliterator.ORDERED) {
            public boolean tryAdvance(Consumer<? super T> action) {
                if(e.hasMoreElements()) {
                    action.accept(e.nextElement());
                    return true;
                }
                return false;
            }
            public void forEachRemaining(Consumer<? super T> action) {
                while(e.hasMoreElements()) action.accept(e.nextElement());
            }
    }, false);
}

Auf der Quellcode-Ebene ist diese Implementierung so einfach wie die Iterator-basierte, eliminiert jedoch die Delegierung von a Spliteratornach a Iterator. Die Leser müssen lediglich die neue API kennenlernen.

Warum nicht Vanille Java verwenden:

Collections.list(enumeration).stream()...

Wie von @MicahZoltu erwähnt, muss jedoch die Anzahl der Elemente in der Aufzählung berücksichtigt werden, da Collections.listzuerst die Aufzählung durchlaufen wird, um die Elemente in eine zu kopieren ArrayList. Von dort aus kann die reguläre streamMethode angewendet werden. Während dies für viele Sammlungsstromoperationen üblich ist, kann dies zu Problemen führen, wenn die Aufzählung zu groß ist (wie unendlich), da die Aufzählung in eine Liste transformiert werden muss. Stattdessen sollten stattdessen die anderen hier beschriebenen Ansätze verwendet werden.

In Java 9 ist es möglich, ein mit einem Einzeiler Enumerationin ein zu konvertieren Stream:

Enumeration<String> en = ... ;
Stream<String> str = StreamSupport.stream(
    Spliterators.spliteratorUnknownSize(en.asIterator(), Spliterator.ORDERED),
    false
);

(Nun, es ist eine ziemlich lange Schlange.)

Wenn Sie nicht mit Java 9 arbeiten, können Sie das manuell mithilfe der in Holgers Antwort angegebenen Technik Enumerationin eine konvertieren .Iterator

Laut Guava-Dokumenten können Sie die folgende Iterators.forEnumeration()Methode verwenden:

Enumeration<Something> enumeration = ...;

Iterator<SomeThing> iterator = Iterators.forEnumeration(enumeration);

In dieser Frage wird erklärt, wie Sie einen Stream von einem Iterator erhalten:

Stream<Something> stream = StreamSupport.stream(
    Spliterators.spliteratorUnknownSize(
        iterator, Spliterator.ORDERED),
    false);

In meiner StreamEx- Bibliothek gibt es eine einfache Methode, StreamEx.of(Enumeration)die den Job erledigt:

Stream<String> stream = StreamEx.of(enumeration);

Beachten Sie, dass dies nicht nur eine Verknüpfung zur @ Holger-Lösung ist, sondern auf unterschiedliche Weise implementiert wird. Insbesondere weist es im Vergleich zu Lösungen, an denen beteiligt ist, signifikant bessere parallele Ausführungseigenschaften auf Spliterators.spliteratorUnknownSize().