Wie schalte ich eine Java-Enumeration in einen Stream???

Habe ich eine Drittanbieter-Bibliothek, die gibt mir eine Enumeration<String>. Ich möchte mit dieser Aufzählung träge wie ein Java-8 Stream, ruft Dinge wie filter, map und flatMap drauf.

Gibt es eine Bibliothek, bei der das in es? Ich bin schon Referenzierung Guave und Apache-Commons-wenn also entweder die haben die Lösung, das wäre ideal.

Alternativ, was ist der beste/einfachste Weg, um ein Enumeration in eine Stream unter Beibehaltung der faulen Natur von allem?

Verwandte: Durchlaufen, die eine Enumeration in Java 8
Die Frage ist zu Fragen, wie man aus einer Enumeration (Java 1.0) in eine Iterator (Java 1.2). Ich Frage Sie, wie schalten Sie es in einen Stream (Java 1.8). Während scheint es, dass die Letzte Antwort in der verlinkten Frage, Antworten diese, dass die Antwort falsch ist, für die Frage. Das Antwort sollte werden, die hier bereitgestellt werden, so dass zukünftige Forscher können erfolgreich finden es. Vielleicht @ArneBurmeister möchten, kopieren Sie die Antwort hier, so dass diese Frage direkt beantworten?
Wieder geöffnet, wie die Antworten der verlinkten Frage nicht diskutieren, das lazy-Verhalten und es wäre auch nicht der richtige Ort zum posten alternative Möglichkeiten zum erstellen einer Stream (als das ist nicht den Umfang der verlinkten Frage).

InformationsquelleAutor Micah Zoltu | 2015-10-20

Diese Antwort bietet bereits eine Lösung an, die erstellt eine Stream aus 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 so faul wie jeder andere Stream, da er nicht alle Gegenstände, bevor die terminal-Aktion eingeleitet wurde und wenn die terminal-Betrieb ist Kurzschluss, es wird iteriert werden nur so viele Elemente wie nötig.

Trotzdem hat es Raum für Verbesserungen. Ich würde immer noch eine forEachRemaining Methode, wenn es eine straight-forward-Methode für die Verarbeitung aller Elemente. Gesagt-Methode aufgerufen werden, indem die Stream Umsetzung für die meisten nicht-Kurzschluss-Operationen:

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

Jedoch, der code oben ist ein Opfer der "mit Iterator weil es so vertraut" antipattern. Die erstellten Iterator erhalten eingewickelt in eine Implementierung der neuen Spliterator - Schnittstelle und bietet keinen Vorteil gegenüber der Umsetzung Spliterator direkt:

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 dem Quell-code-Ebene, diese Implementierung ist so einfach wie die Iterator-basiert, sondern beseitigt die delegation aus Spliterator zu einem Iterator. Es erfordert nur Ihre Leser zu erfahren, über das neue API.

Gute Sachen Holger. Was sind die Vorteile der Verwendung von Spliterator.Hier BESTELLT vs andere Werte?
bedeutet, dass es einen definierten Begegnung Ordnung ist, so bedeutet es, dass die Stream-Implementierung ist nicht erlaubt, das zu tun-Optimierungen, basierend auf der Annahme, die Daten ungeordnet. Da für eine unbekannte Enumeration wissen wir nicht, ob die Reihenfolge eine Bedeutung hat, müssen wir davon ausgehen, dass es könnte haben einen Sinn und geben diese Eigenschaft. Der Anrufer kann Sie noch rufen unordered() auf dem stream, wenn Sie wissen, dass die Reihenfolge ist irrelevant für die bestimmten Daten, zum aktivieren der Optimierungen. Aber unsere erste Prämisse muss sein, dass die Reihenfolge könnte wichtig sein.

InformationsquelleAutor Holger

87

Warum nicht mit Vanille-Java :
```
Collections.list(enumeration).stream()...
```
Jedoch als wissen von @MicahZoltu, die Anzahl der Elemente in der Aufzählung berücksichtigt werden, da Collections.list wird die erste Iteration über die enumeration zu kopieren die Elemente in einem ArrayList. Von dort aus werden die regelmäßigen stream Methode verwendet werden kann. Dies ist zwar üblich für viele Sammlung stream-Operationen, wenn die Aufzählung ist zu groß (wie unendlich), kann dies zu Problemen führen, da die enumeration umgewandelt werden in eine Liste, dann den anderen Ansätzen, die hier beschrieben wird, sollte stattdessen verwendet werden.
- Das auflisten der gesamten enumeration, um Sie in eine Liste und dann geben Sie die stream-Zugriff auf die Liste. Wenn die Aufzählung ist klein, das ist wohl ein vernünftiger Ansatz. Wenn die Aufzählung ist sehr groß, könnte dies ein teurer und unnötiger Vorgang. Wenn die Aufzählung ist unendlich, dieser stürzt Ihre Anwendung.
- In der Tat. Das ist ein Punkt, ich ll update die Antwort. Dank
- Ich mag deine Lösung!
InformationsquelleAutor Brice
24

In Java 9 ist es möglich, zu konvertieren, ein Enumeration zu einem Stream mit einem one-liner:
```
Enumeration<String> en = ... ;
Stream<String> str = StreamSupport.stream(
    Spliterators.spliteratorUnknownSize(en.asIterator(), Spliterator.ORDERED),
    false
);
```
(Gut, es ist eine ziemlich lange Zeile.)

Wenn Sie nicht auf Java 9, können Sie konvertieren die Enumeration in eine Iterator manuell mit Hilfe der Technik in Holger ' s Antwort.
- Können wir machen fast alles, was ein one-liner, wenn wir uns die Zeile lang genug ist ;^)
InformationsquelleAutor Stuart Marks
8

Laut Guave docs, könnten Sie die Iterators.forEnumeration() Methode:
```
Enumeration<Something> enumeration = ...;

Iterator<SomeThing> iterator = Iterators.forEnumeration(enumeration);
```
Und in diese Frage, es wird erklärt, wie man einen stream von einem iterator:
```
Stream<Something> stream = StreamSupport.stream(
    Spliterators.spliteratorUnknownSize(
        iterator, Spliterator.ORDERED),
    false);
```
- Obwohl es kann funktionieren, in diesem Fall, dass die iterierbar ist nicht wirklich ein Durchsuchbar: Sie iterieren es genau einmal!
- Das gleiche passiert mit streams. Verwenden und entsorgen, sagen Sie 🙂
- Im Kontext ist es vollkommen ok, aber es ist ein Fehler warten, um zu geschehen, weil es deklariert ein Objekt mit eine andere Semantik als das, was seine Oberfläche sagen. Noch wichtiger ist es IMHO ein Missbrauch der Iterierbar-Schnittstelle, die durch Zufall passiert zu sein zuweisbare aus einem lambda-Ausdruck, ist aber nicht eigentlich eine @FunctionalInterface
- Jetzt habe ich Ihren Punkt, siehe edit.
InformationsquelleAutor Federico Peralta Schaffner
4

In meinem StreamEx Bibliothek gibt ' s einfache Methode StreamEx.der(Aufzählung), die nicht den job:
```
Stream<String> stream = StreamEx.of(enumeration);
```
Beachten Sie, dass es nicht nur eine Verknüpfung zu der @Holger Lösung, aber umgesetzt in unterschiedlicher Art und Weise. Insbesondere hat es deutlich bessere parallele Ausführung Eigenschaften im Vergleich zu Lösungen mit Spliterators.spliteratorUnknownSize().

InformationsquelleAutor Tagir Valeev

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.