Abrufen einer Liste aus einem java.util.stream.Stream in Java 8

Ich habe mit Java 8 Lambdas herumgespielt, um Sammlungen einfach zu filtern. Ich habe jedoch keinen präzisen Weg gefunden, um das Ergebnis als neue Liste innerhalb derselben Anweisung abzurufen. Hier ist mein bisher prägnantester Ansatz:

List<Long> sourceLongList = Arrays.asList(1L, 10L, 50L, 80L, 100L, 120L, 133L, 333L);
List<Long> targetLongList = new ArrayList<>();
sourceLongList.stream().filter(l -> l > 100).forEach(targetLongList::add);

Beispiele im Internet haben meine Frage nicht beantwortet, da sie aufhören, ohne eine neue Ergebnisliste zu erstellen. Es muss einen prägnanteren Weg geben. Ich hätte erwartet , dass, dass die StreamKlasse hat Methoden toList(), toSet()...

Gibt es eine Möglichkeit, die Variablen targetLongListdirekt durch die dritte Zeile zuzuweisen?

Was Sie tun, ist möglicherweise der einfachste Weg, vorausgesetzt, Ihr Stream bleibt sequentiell - andernfalls müssen Sie vorher sequential () aufrufen forEach.

[spätere Bearbeitung: Der Grund für den Aufruf von sequential () ist, dass der Code in seiner forEach(targetLongList::add)jetzigen Form ( ) rassig wäre, wenn der Stream parallel wäre. Selbst dann wird der beabsichtigte Effekt nicht erreicht, da dies forEachexplizit nicht deterministisch ist - selbst in einem sequentiellen Stream ist die Reihenfolge der Elementverarbeitung nicht garantiert. Sie müssten verwenden forEachOrdered, um die korrekte Bestellung sicherzustellen. Die Absicht der Stream-API-Designer ist, dass Sie in dieser Situation den Collector verwenden (siehe unten).]

Eine Alternative ist

targetLongList = sourceLongList.stream()
    .filter(l -> l > 100)
    .collect(Collectors.toList());

Aktualisiert:

Ein anderer Ansatz ist zu verwenden Collectors.toList:

targetLongList = 
    sourceLongList.stream().
    filter(l -> l > 100).
    collect(Collectors.toList());

Vorherige Lösung:

Ein anderer Ansatz ist zu verwenden Collectors.toCollection:

targetLongList = 
    sourceLongList.stream().
    filter(l -> l > 100).
    collect(Collectors.toCollection(ArrayList::new));

Ich verwende gerne eine util-Methode, die einen Kollektor zurückgibt, ArrayListwenn ich dies möchte.

Ich denke, die verwendete Lösung Collectors.toCollection(ArrayList::new)ist für eine so häufige Operation etwas zu laut.

Beispiel:

ArrayList<Long> result = sourceLongList.stream()
    .filter(l -> l > 100)
    .collect(toArrayList());

public static <T> Collector<T, ?, ArrayList<T>> toArrayList() {
    return Collectors.toCollection(ArrayList::new);
}

Mit dieser Antwort möchte ich auch zeigen, wie einfach es ist, benutzerdefinierte Kollektoren zu erstellen und zu verwenden, was im Allgemeinen sehr nützlich ist.

Wenn Sie über ein Array von Grundelementen verfügen, können Sie die in Eclipse- Sammlungen verfügbaren Grundelement-Sammlungen verwenden .

LongList sourceLongList = LongLists.mutable.of(1L, 10L, 50L, 80L, 100L, 120L, 133L, 333L);
LongList targetLongList = sourceLongList.select(l -> l > 100);

Wenn Sie die sourceLongList nicht ändern können von List:

List<Long> sourceLongList = Arrays.asList(1L, 10L, 50L, 80L, 100L, 120L, 133L, 333L);
List<Long> targetLongList = 
    ListAdapter.adapt(sourceLongList).select(l -> l > 100, new ArrayList<>());

Wenn Sie verwenden möchten LongStream:

long[] sourceLongs = new long[]{1L, 10L, 50L, 80L, 100L, 120L, 133L, 333L};
LongList targetList = 
    LongStream.of(sourceLongs)
    .filter(l -> l > 100)
    .collect(LongArrayList::new, LongArrayList::add, LongArrayList::addAll);

Hinweis: Ich bin ein Mitarbeiter von Eclipse Collections.

Ein wenig effizienter Weg (vermeiden Sie das Erstellen der Quellliste und das automatische Entpacken durch den Filter):

List<Long> targetLongList = LongStream.of(1L, 10L, 50L, 80L, 100L, 120L, 133L, 333L)
    .filter(l -> l > 100)
    .boxed()
    .collect(Collectors.toList());

collect(Collectors.toList());

Dies ist der Aufruf, mit dem Sie jeden Stream in List konvertieren können.

konkreter:

    List<String> myList = stream.collect(Collectors.toList()); 

von:

https://www.geeksforgeeks.org/collectors-tolist-method-in-java-with-examples/

Wenn es Ihnen nichts ausmacht, Bibliotheken von Drittanbietern zu verwenden, enthält die Cyclops-React- Bibliothek von AOL (Offenlegung, an der ich beteiligt bin) Erweiterungen für alle JDK-Sammlungstypen , einschließlich List . Die ListX-Schnittstelle erweitert java.util.List und fügt eine große Anzahl nützlicher Operatoren hinzu, einschließlich Filter.

Sie können einfach schreiben-

ListX<Long> sourceLongList = ListX.of(1L, 10L, 50L, 80L, 100L, 120L, 133L, 333L);
ListX<Long> targetLongList = sourceLongList.filter(l -> l > 100);

ListX kann auch aus einer vorhandenen Liste erstellt werden (über ListX.fromIterable).

Es gibt eine andere Variante der Sammelmethode, die von der LongStream-Klasse und in ähnlicher Weise auch von den IntStream- und DoubleStream-Klassen bereitgestellt wird.

<R> R collect(Supplier<R> supplier,
              ObjLongConsumer<R> accumulator,
              BiConsumer<R,R> combiner)

Führt eine veränderbare Reduktionsoperation für die Elemente dieses Streams durch. Eine veränderbare Verkleinerung ist eine Verkleinerung, bei der der reduzierte Wert ein veränderbarer Ergebniscontainer ist, z. B. eine ArrayList, und Elemente durch Aktualisieren des Ergebnisstatus und nicht durch Ersetzen des Ergebnisses eingefügt werden. Dies ergibt ein Ergebnis, das entspricht:

R result = supplier.get();
  for (long element : this stream)
       accumulator.accept(result, element);
  return result;

Wie beim Reduzieren (long, LongBinaryOperator) können Erfassungsvorgänge parallelisiert werden, ohne dass eine zusätzliche Synchronisierung erforderlich ist. Dies ist eine Terminaloperation.

Die Antwort auf Ihre Frage mit dieser Erhebungsmethode lautet wie folgt:

    LongStream.of(1L, 2L, 3L, 3L).filter(i -> i > 2)
    .collect(ArrayList::new, (list, value) -> list.add(value)
    , (list1, list2) -> list1.addAll(list2));

Unten ist die Methodenreferenzvariante aufgeführt, die ziemlich intelligent ist, aber einige, die schwer zu verstehen sind:

     LongStream.of(1L, 2L, 3L, 3L).filter(i -> i > 2)
    .collect(ArrayList::new, List::add , List::addAll);

Unten wird die HashSet-Variante sein:

     LongStream.of(1L, 2L, 3L, 3).filter(i -> i > 2)
     .collect(HashSet::new, HashSet::add, HashSet::addAll);

Ähnlich sieht die LinkedList-Variante aus:

     LongStream.of(1L, 2L, 3L, 3L)
     .filter(i -> i > 2)
     .collect(LinkedList::new, LinkedList::add, LinkedList::addAll);

Falls jemand (wie ich) da draußen nach Wegen sucht, mit Objekten umzugehen, anstatt mit primitiven Typen, dann benutze sie mapToObj()

String ss = "An alternative way is to insert the following VM option before "
        + "the -vmargs option in the Eclipse shortcut properties(edit the "
        + "field Target inside the Shortcut tab):";

List<Character> ll = ss
                        .chars()
                        .mapToObj(c -> new Character((char) c))
                        .collect(Collectors.toList());

System.out.println("List type: " + ll.getClass());
System.out.println("Elem type: " + ll.get(0).getClass());
ll.stream().limit(50).forEach(System.out::print);

Drucke:

List type: class java.util.ArrayList
Elem type: class java.lang.Character
An alternative way is to insert the following VM o

String joined = 
                Stream.of(isRead?"read":"", isFlagged?"flagged":"", isActionRequired?"action":"", isHide?"hide":"")
                      .filter(s -> s != null && !s.isEmpty())
                      .collect(Collectors.joining(","));

Hier ist Code von AbacusUtil

LongStream.of(1, 10, 50, 80, 100, 120, 133, 333).filter(e -> e > 100).toList();

Offenlegung: Ich bin der Entwickler von AbacusUtil.

Sie können den Code wie folgt umschreiben:

List<Long> sourceLongList = Arrays.asList(1L, 10L, 50L, 80L, 100L, 120L, 133L, 333L);
List<Long> targetLongList = sourceLongList.stream().filter(l -> l > 100).collect(Collectors.toList());

So sammeln Sie in einer veränderlichen Liste:

targetList = sourceList.stream()
                       .filter(i -> i > 100) //apply filter
                       .collect(Collectors.toList());

So sammeln Sie in einer unveränderlichen Liste:

targetList = sourceList.stream()
                       .filter(i -> i > 100) //apply filter
                       .collect(Collectors.toUnmodifiableList());

Erklärung von collectaus dem JavaDoc :

Führt mit einem Collector eine veränderbare Reduktionsoperation für die Elemente dieses Streams durch. Ein Collector kapselt die Funktionen, die als zu sammelnde Argumente verwendet werden (Supplier, BiConsumer, BiConsumer), und ermöglicht die Wiederverwendung von Erfassungsstrategien und die Zusammensetzung von Erfassungsvorgängen wie Gruppierung oder Partitionierung auf mehreren Ebenen. Wenn der Stream parallel ist und der Collector gleichzeitig ist und entweder der Stream ungeordnet oder der Collector ungeordnet ist, wird eine gleichzeitige Reduzierung durchgeführt (Einzelheiten zur gleichzeitigen Reduzierung finden Sie unter Collector).

Dies ist eine Terminaloperation.

Bei paralleler Ausführung können mehrere Zwischenergebnisse instanziiert, aufgefüllt und zusammengeführt werden, um die Isolation veränderlicher Datenstrukturen aufrechtzuerhalten. Daher ist auch bei paralleler Ausführung mit nicht threadsicheren Datenstrukturen (wie ArrayList) keine zusätzliche Synchronisation für eine parallele Reduzierung erforderlich.

Wenn Sie dies nicht verwenden parallel(), funktioniert dies

List<Long> sourceLongList = Arrays.asList(1L, 10L, 50L, 80L, 100L, 120L, 133L, 333L);

List<Long> targetLongList =  new ArrayList<Long>();

sourceLongList.stream().peek(i->targetLongList.add(i)).collect(Collectors.toList());