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

Question

Ich spielte mit Java 8 Lambdas, um Sammlungen einfach zu filtern. Aber ich habe keine übersichtliche Methode gefunden, das Ergebnis als neue Liste innerhalb derselben Anweisung abzurufen. Hier ist meine knappste Ansatz so weit:

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 Netz antwortete nicht auf meine Frage, weil sie ohne Erzeugen eines neuen Ergebnisliste stoppen. Es muss einen prägnanteren Weg geben. Ich habe erwartet, dass, dass die Stream Klasse verfügt über Methoden wie toList(), toSet(), ...

Gibt es eine Möglichkeit, dass die Variablen targetLongList können direkt von der dritten Zeile zugeordnet werden werden?

Answer 1

Was Sie tun, ist möglicherweise der einfachste Weg, sofern Ihr Stream sequentiell bleibt — sonst müssen Sie einen Aufruf von sequential() vor forEach.

[später bearbeiten: Der Grund für den Aufruf von sequential() ist notwendig, dass der Code, wie er steht (forEach(targetLongList::add)) wäre rassig, wenn der Strom parallel war. Selbst dann wird es den beabsichtigten Effekt nicht erreichen, da forEach explizit nicht deterministisch — ist, selbst in einem sequentiellen Strom ist die Reihenfolge der Elementverarbeitung nicht garantiert. Sie müssen forEachOrdered verwenden, um die korrekte Bestellung sicherzustellen. Die Absicht des Stream-API-Designers ist, dass man Sammler in dieser Situation, wie weiter unten]

Eine Alternative ist

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

Answer 2

Ein weiterer Ansatz Collectors.toCollection verwenden zu verwenden ist.

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

Answer 3

In Fall jemand (wie ich) da draußen nach Wegen sucht, mit Objekten statt primitiver Typen umzugehen, dann benutze 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); 

druckt:

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

Answer 4

Ich mag eine util-Methode verwenden, die einen Kollektor für ArrayList zurückgibt, wenn das ist, was ich will.

Ich denke, die Lösung mit Collectors.toCollection(ArrayList::new) ist ein wenig zu laut für eine solche gemeinsame Operation.

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, die ich mag auch zeigen, wie einfach es zu schaffen ist und benutzerdefinierte Sammler zu verwenden, die in der Regel sehr nützlich ist.

Answer 5

Wenn es Ihnen nichts ausmacht, 3rd-Party-Bibliotheken zu verwenden, hat AOL's cyclops-react lib (Offenlegung ich einen Beitrag) Erweiterungen für alle JDK Collection Typen, einschließlich List. Die ListX-Schnittstelle erweitert java.util.List und fügt eine große Anzahl nützlicher Operatoren hinzu, einschließlich Filter.

können Sie einfach

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

Listex auch aus einer bestehenden Liste erstellt werden kann (via Listex schreib.fromIterable)

Answer 6

Wenn Sie über ein Array von Primitiven verfügen, können Sie die in Eclipse Collections verfügbaren Primitivsammlungen verwenden.

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

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

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 Beitrag Kollektionen Eclipse.

Answer 7

Wenn Sie nicht parallel() verwenden dies funktionieren wird

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

Answer 8

Eine wenig effiziente Art und Weise (vermeiden die die Quellenliste und die Auto-Unboxing durch die Filter erstellen):

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

Answer 9

hier ist der Code von AbacusUtil

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

Disclosure: ich bin der Entwickler AbacusU bis.

Answer 10

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

Answer 11

collect(Collectors.toList()); 

Das ist der Ruf, die alle Stream konvertieren verwenden können, um Liste.