Recupero di un elenco da java.util.stream.Stream in Java 8

Stavo giocando con lambda Java 8 per filtrare facilmente le raccolte. Ma non ho trovato un modo conciso per recuperare il risultato come un nuovo elenco all'interno della stessa istruzione. Ecco il mio approccio più conciso finora:

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

Gli esempi in rete non hanno risposto alla mia domanda perché si fermano senza generare un nuovo elenco di risultati. Deve esserci un modo più conciso. Mi sarei aspettato, che la Streamclasse ha metodi come toList(), toSet(), ...

C'è un modo in cui le variabili targetLongListpossono essere assegnate direttamente dalla terza riga?

Quello che stai facendo potrebbe essere il modo più semplice, a condizione che il tuo stream rimanga sequenziale, altrimenti dovrai prima chiamare una chiamata sequenziale () forEach.

[modifica successiva: la ragione per cui la chiamata a sequential () è necessaria è che il codice così com'è ( forEach(targetLongList::add)) sarebbe filante se il flusso fosse parallelo. Anche in questo caso, non otterrà l'effetto previsto, come forEachè esplicitamente non deterministico, anche in un flusso sequenziale l'ordine di elaborazione degli elementi non è garantito. Dovresti utilizzare forEachOrderedper garantire un ordine corretto. L'intenzione dei progettisti dell'API Stream è quella di utilizzare il raccoglitore in questa situazione, come di seguito.]

Un'alternativa è

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

aggiornato:

Un altro approccio è usare Collectors.toList:

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

Soluzione precedente:

Un altro approccio è usare Collectors.toCollection:

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

Mi piace usare un metodo util che restituisce un collezionista per ArrayListquando è quello che voglio.

Penso che la soluzione utilizzata Collectors.toCollection(ArrayList::new)sia un po 'troppo rumorosa per un'operazione così comune.

Esempio:

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

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

Con questa risposta voglio anche dimostrare quanto sia semplice creare e utilizzare collezionisti personalizzati, il che è molto utile in generale.

Se si dispone di una matrice di primitive, è possibile utilizzare le raccolte di primitive disponibili nelle raccolte di Eclipse .

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

Se non puoi modificare sourceLongList da 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<>());

Se vuoi usare 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);

Nota: sono un collaboratore delle raccolte Eclipse.

Un modo un po 'più efficiente (evita di creare l'Elenco sorgenti e l'auto-unboxing dal filtro):

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

collect(Collectors.toList());

Questa è la chiamata che è possibile utilizzare per convertire qualsiasi stream in elenco.

più concretamente:

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

a partire dal:

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

Se non ti dispiace usare librerie di terze parti, la libreria AOL con reazione al ciclope (la divulgazione che io sono un collaboratore) ha estensioni per tutti i tipi di raccolte JDK , incluso List . L'interfaccia ListX estende java.util.List e aggiunge un gran numero di operatori utili, incluso il filtro.

Puoi semplicemente scrivere-

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

ListX può anche essere creato da un Elenco esistente (tramite ListX.fromIterable)

Esiste un'altra variante del metodo di raccolta fornito dalla classe LongStream e in modo simile anche dalle classi IntStream e DoubleStream.

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

Esegue un'operazione di riduzione mutabile sugli elementi di questo flusso. Una riduzione mutabile è quella in cui il valore ridotto è un contenitore di risultati mutabile, come un ArrayList, e gli elementi vengono incorporati aggiornando lo stato del risultato anziché sostituendolo. Questo produce un risultato equivalente a:

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

Come ridurre (long, LongBinaryOperator), le operazioni di raccolta possono essere parallelizzate senza richiedere ulteriore sincronizzazione. Questa è un'operazione terminale.

E la risposta alla tua domanda con questo metodo di raccolta è la seguente:

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

Di seguito è riportata la variante di riferimento del metodo che è abbastanza intelligente ma alcuni che sono difficili da capire:

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

Di seguito sarà la variante di HashSet:

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

Allo stesso modo la variante di LinkedList è così:

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

Nel caso in cui qualcuno (come me) là fuori stia cercando dei modi per gestire gli oggetti anziché i tipi primitivi, quindi usarli 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);

stampe:

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

Ecco il codice di AbacusUtil

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

Divulgazione ： Sono lo sviluppatore di AbacusUtil.

Puoi riscrivere il codice come di seguito:

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

Per raccogliere in un elenco mutabile:

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

Per raccogliere in un elenco immutabile:

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

Spiegazione di collectda JavaDoc :

Esegue un'operazione di riduzione mutabile sugli elementi di questo flusso utilizzando un servizio di raccolta. Un Collector incapsula le funzioni utilizzate come argomenti da raccogliere (Fornitore, BiConsumer, BiConsumer), consentendo il riutilizzo delle strategie di raccolta e la composizione delle operazioni di raccolta come il raggruppamento o il partizionamento a più livelli. Se il flusso è parallelo e Collector è simultaneo e il flusso non è ordinato o il collector non è ordinato, verrà eseguita una riduzione simultanea (vedere Collector per dettagli sulla riduzione simultanea).

Questa è un'operazione terminale.

Se eseguiti in parallelo, è possibile creare istanze, compilare e unire più risultati intermedi in modo da mantenere l'isolamento delle strutture di dati mutabili. Pertanto, anche se eseguito in parallelo con strutture dati non thread-safe (come ArrayList), non è necessaria alcuna sincronizzazione aggiuntiva per una riduzione parallela.

Se non lo usi parallel(), funzionerà

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