Pobieranie listy z java.util.stream.Stream w Javie 8

Bawiłem się lambdami Java 8, aby łatwo filtrować kolekcje. Ale nie znalazłem zwięzłego sposobu na uzyskanie wyniku jako nowej listy w ramach tej samej instrukcji. Oto moje najbardziej zwięzłe podejście do tej pory:

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

Przykłady w sieci nie odpowiedziały na moje pytanie, ponieważ zatrzymały się bez wygenerowania nowej listy wyników. Musi być bardziej zwięzły sposób. Liczyłam, że Streamklasa ma sposobów toList(), toSet()...

Czy istnieje sposób, aby zmienne targetLongListmożna przypisać bezpośrednio w trzecim wierszu?

To, co robisz, może być najprostszym sposobem, pod warunkiem, że Twój strumień pozostaje sekwencyjny - w przeciwnym razie będziesz musiał wcześniej wywołać funkcję sekwencyjną () forEach.

[późniejsza edycja: powodem, dla którego konieczne jest wywołanie funkcji sekwencyjnej (), jest to, że kod w jego obecnej postaci ( forEach(targetLongList::add)) byłby bardziej ryzykowny, gdyby strumień był równoległy. Nawet wtedy nie osiągnie zamierzonego efektu, co forEachjest wyraźnie niedeterministyczne - nawet w strumieniu sekwencyjnym kolejność przetwarzania elementów nie jest gwarantowana. Musisz użyć, forEachOrderedaby zapewnić prawidłowe zamówienie. Intencją projektantów Stream API jest użycie kolektora w takiej sytuacji, jak poniżej.]

Alternatywą jest

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

Zaktualizowano:

Innym podejściem jest użycie Collectors.toList:

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

Poprzednie rozwiązanie:

Innym podejściem jest użycie Collectors.toCollection:

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

Lubię używać metody util, która zwraca kolektor, ArrayListgdy tego właśnie chcę.

Myślę, że użycie tego rozwiązania Collectors.toCollection(ArrayList::new)jest trochę zbyt głośne w przypadku tak powszechnej operacji.

Przykład:

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

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

Tą odpowiedzią chcę również zademonstrować, jak łatwo jest tworzyć niestandardowe kolektory i korzystać z nich, co jest ogólnie bardzo przydatne.

Jeśli masz tablicę prymitywów, możesz użyć pierwotnych kolekcji dostępnych w Eclipse Collections .

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

Jeśli nie możesz zmienić sourceLongList z 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<>());

Jeśli chcesz użyć 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);

Uwaga: Jestem współtwórcą kolekcji Eclipse.

Trochę bardziej wydajny sposób (unikaj tworzenia listy źródłowej i automatycznego rozpakowywania przez filtr):

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

collect(Collectors.toList());

To jest połączenie, którego możesz użyć do konwersji dowolnego strumienia na listę.

bardziej konkretnie:

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

od:

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

Jeśli nie przeszkadza przy użyciu bibliotek 3rd party, AOL Cyklop reagują lib (ujawnienie jestem specjalista) posiada rozszerzenia dla wszystkich JDK Kolekcja typów, w tym listy . Interfejs ListX rozszerza java.util.List i dodaje wiele przydatnych operatorów, w tym filtr.

Możesz po prostu napisać

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

ListX można również utworzyć z istniejącej listy (poprzez ListX.fromIterable)

Istnieje inny wariant metody kolekcjonowania zapewniany przez klasę LongStream, podobnie jak klasy IntStream i DoubleStream.

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

Wykonuje zmienną operację redukcji na elementach tego strumienia. Zmienna redukcja to taka, w której zmniejszona wartość jest zmiennym pojemnikiem wyników, takim jak ArrayList, a elementy są włączane przez aktualizację stanu wyniku zamiast zastępowania wyniku. Daje to wynik równoważny z:

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

Podobnie jak redukcja (long, LongBinaryOperator), operacje zbierania mogą być równoległe bez konieczności dodatkowej synchronizacji. To jest operacja terminalowa.

Odpowiedź na twoje pytanie za pomocą tej metody zbierania jest następująca:

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

Poniżej znajduje się wariant referencyjny metody, który jest dość sprytny, ale niektóre trudne do zrozumienia:

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

Poniżej będzie wariant HashSet:

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

Podobnie wariant LinkedList wygląda następująco:

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

Jeśli ktoś (jak ja) szuka sposobów radzenia sobie z obiektami zamiast typów pierwotnych, użyj 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);

drukuje:

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

Oto kod AbacusUtil

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

Ujawnienie ： Jestem programistą AbacusUtil.

Możesz przepisać kod jak poniżej:

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

Aby zebrać na zmiennej liście:

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

Aby zebrać na niezmiennej liście:

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

Objaśnienie collectz JavaDoc :

Wykonuje zmienną operację redukcji elementów tego strumienia za pomocą Collectora. Collector hermetyzuje funkcje używane jako argumenty do zbierania (dostawca, BiConsumer, BiConsumer), pozwalając na ponowne użycie strategii zbierania i składanie operacji zbierania, takich jak grupowanie lub partycjonowanie na wielu poziomach. Jeśli strumień jest równoległy, a moduł zbierający jest współbieżny, a albo strumień jest nieuporządkowany, albo moduł zbierający jest nieuporządkowany, wówczas zostanie wykonana równoczesna redukcja (szczegółowe informacje na temat redukcji współbieżnej można znaleźć w sekcji Kolektor).

To jest operacja terminalowa.

Podczas wykonywania równoległego wiele wyników pośrednich może być utworzonych, wypełnionych i scalonych, aby zachować izolację zmiennych danych. Dlatego nawet przy równoległym wykonywaniu z niechronionymi wątkami strukturami danych (takimi jak ArrayList), nie jest wymagana dodatkowa synchronizacja dla równoległej redukcji.

Jeśli nie użyjesz, parallel()to zadziała

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