Holen Sie sich das letzte Element von Stream / List in einem Einzeiler

Wie kann ich das letzte Element eines Streams oder einer Liste im folgenden Code abrufen?

Wo data.careasist ein List<CArea>:

CArea first = data.careas.stream()
                  .filter(c -> c.bbox.orientationHorizontal).findFirst().get();

CArea last = data.careas.stream()
                 .filter(c -> c.bbox.orientationHorizontal)
                 .collect(Collectors.toList()).; //how to?

Wie Sie sehen können filter, ist es nicht schwer , das erste Element mit einem bestimmten zu bekommen .

Das letzte Element in einem Einzeiler zu bekommen, ist jedoch ein echtes Problem:

• Es scheint, ich kann es nicht direkt von a erhalten Stream. (Es wäre nur für endliche Ströme sinnvoll)
• Es scheint auch, dass Sie Dinge wie first()und last()von der ListBenutzeroberfläche nicht bekommen können, was wirklich ein Schmerz ist.

Ich sehe kein Argument dafür, dass in der Schnittstelle keine first()und- last()Methode angegeben Listwird, da die Elemente dort geordnet sind und außerdem die Größe bekannt ist.

Aber gemäß der ursprünglichen Antwort: Wie erhält man das letzte Element eines Endlichen Stream?

Persönlich ist dies der nächste, den ich bekommen könnte:

int lastIndex = data.careas.stream()
        .filter(c -> c.bbox.orientationHorizontal)
        .mapToInt(c -> data.careas.indexOf(c)).max().getAsInt();
CArea last = data.careas.get(lastIndex);

Es beinhaltet jedoch die Verwendung eines indexOfElements für jedes Element, was Sie im Allgemeinen höchstwahrscheinlich nicht möchten, da es die Leistung beeinträchtigen kann.

Es ist möglich, das letzte Element mit der Methode Stream :: redu zu erhalten . Die folgende Auflistung enthält ein minimales Beispiel für den allgemeinen Fall:

Stream<T> stream = ...; // sequential or parallel stream
Optional<T> last = stream.reduce((first, second) -> second);

Diese Implementierung funktioniert für alle geordneten Streams (einschließlich aus Listen erstellter Streams ). Bei ungeordneten Streams ist aus offensichtlichen Gründen nicht angegeben, welches Element zurückgegeben wird.

Die Implementierung funktioniert sowohl für sequentielle als auch für parallele Streams . Das mag auf den ersten Blick überraschend sein, und in der Dokumentation wird dies leider nicht explizit angegeben. Es ist jedoch ein wichtiges Merkmal von Streams, und ich versuche es zu klären:

• Das Javadoc für die Methode Stream :: Reduce gibt an, dass es " nicht auf die sequentielle Ausführung beschränkt ist " .
• Das Javadoc verlangt auch, dass die "Akkumulatorfunktion eine assoziative sein muss , nicht störende , zustandslose Funktion zum Kombinieren zweier Werte sein muss" , was offensichtlich für den Lambda-Ausdruck der Fall ist(first, second) -> second.
• Im Javadoc für Reduktionsoperationen heißt es: "Die Streams-Klassen haben mehrere Formen allgemeiner Reduktionsoperationen, die als redu () und collect () [..] bezeichnet werden" und "eine ordnungsgemäß konstruierte Reduktionsoperation ist von Natur aus parallelisierbar , solange die Funktion (en) ), die zur Verarbeitung der Elemente verwendet werden, sind assoziativ und zustandslos . "

Die Dokumentation für die eng verwandten Collectors ist noch expliziter: "Um sicherzustellen, dass sequentielle und parallele Ausführungen erzeugen gleichwertige Ergebnisse erzielt werden , müssen die Kollektor Funktionen eine Identität erfüllen und eine Assoziativität Zwänge.“

Zurück zur ursprünglichen Frage: Der folgende Code speichert einen Verweis auf das letzte Element in der Variablen lastund löst eine Ausnahme aus, wenn der Stream leer ist. Die Komplexität ist in der Länge des Stroms linear.

CArea last = data.careas
                 .stream()
                 .filter(c -> c.bbox.orientationHorizontal)
                 .reduce((first, second) -> second).get();

Wenn Sie eine Sammlung (oder allgemeiner eine Iterable) haben, können Sie die von Google Guava verwenden

Iterables.getLast(myIterable)

als praktischer Oneliner.

Ein Liner (kein Stream erforderlich;):

Object lastElement = list.get(list.size()-1);

Guave hat eine spezielle Methode für diesen Fall:

Stream<T> stream = ...;
Optional<T> lastItem = Streams.findLast(stream);

Es ist gleichbedeutend mit, stream.reduce((a, b) -> b)aber die Entwickler behaupten, dass es eine viel bessere Leistung hat.

Aus der Dokumentation :

Die Laufzeit dieser Methode liegt zwischen O (log n) und O (n) und ist bei effizient aufteilbaren Streams besser.

Es ist erwähnenswert, dass sich diese Methode wie folgt verhält, wenn der Stream ungeordnet ist findAny().

Wenn Sie die letzten N Elemente erhalten müssen. Verschluss kann verwendet werden. Der folgende Code verwaltet eine externe Warteschlange mit fester Größe, bis der Stream das Ende erreicht.

    final Queue<Integer> queue = new LinkedList<>();
    final int N=5;
    list.stream().peek((z) -> {
        queue.offer(z);
        if (queue.size() > N)
            queue.poll();
    }).count();

Eine andere Option könnte darin bestehen, den Reduzierungsvorgang unter Verwendung der Identität als Warteschlange zu verwenden.

    final int lastN=3;
    Queue<Integer> reduce1 = list.stream()
    .reduce( 
        (Queue<Integer>)new LinkedList<Integer>(), 
        (m, n) -> {
            m.offer(n);
            if (m.size() > lastN)
               m.poll();
            return m;
    }, (m, n) -> m);

    System.out.println("reduce1 = " + reduce1);

Sie können auch die Funktion skip () wie folgt verwenden ...

long count = data.careas.count();
CArea last = data.careas.stream().skip(count - 1).findFirst().get();

es ist super einfach zu bedienen.