Récupération d'une liste à partir d'un java.util.stream.Stream dans Java 8

Je jouais avec des lambdas Java 8 pour filtrer facilement les collections. Mais je n'ai pas trouvé de moyen concis pour récupérer le résultat sous la forme d'une nouvelle liste dans la même déclaration. Voici mon approche la plus concise à ce jour:

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

Les exemples sur le net n'ont pas répondu à ma question car ils s'arrêtent sans générer de nouvelle liste de résultats. Il doit y avoir un moyen plus concis. Je me serais attendu, que la Streamclasse a des méthodes comme toList(), toSet()...

Existe-t-il un moyen d' targetLongListaffecter directement les variables par la troisième ligne?

Ce que vous faites peut être le moyen le plus simple, à condition que votre flux reste séquentiel, sinon vous devrez auparavant appeler séquentiel () forEach.

[édition ultérieure: la raison pour laquelle l'appel à sequential () est nécessaire est que le code tel qu'il est ( forEach(targetLongList::add)) serait racé si le flux était parallèle. Même alors, il n'obtiendra pas l'effet escompté, comme cela forEachest explicitement non déterministe - même dans un flux séquentiel, l'ordre de traitement des éléments n'est pas garanti. Vous devrez utiliser forEachOrderedpour assurer une commande correcte. L'intention des concepteurs d'API Stream est que vous utilisiez le collecteur dans cette situation, comme ci-dessous.]

Une alternative est

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

Mise à jour:

Une autre approche consiste à utiliser Collectors.toList:

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

Solution précédente:

Une autre approche consiste à utiliser Collectors.toCollection:

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

J'aime utiliser une méthode util qui retourne un collecteur ArrayListquand c'est ce que je veux.

Je pense que la solution utilisée Collectors.toCollection(ArrayList::new)est un peu trop bruyante pour une opération aussi courante.

Exemple:

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

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

Avec cette réponse, je veux également démontrer à quel point il est simple de créer et d'utiliser des collecteurs personnalisés, ce qui est très utile en général.

Si vous disposez d'un tableau de primitives, vous pouvez utiliser les collections de primitives disponibles dans les collections Eclipse .

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

Si vous ne pouvez pas modifier la sourceLongList de 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<>());

Si vous souhaitez utiliser 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);

Remarque: je suis un contributeur aux collections Eclipse.

Un moyen un peu plus efficace (évitez la création de la liste source et la décompression automatique par le filtre):

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

collect(Collectors.toList());

Il s'agit de l'appel que vous pouvez utiliser pour convertir n'importe quel flux en liste.

plus concrètement:

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

de:

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

Si cela ne vous dérange pas d'utiliser des bibliothèques tierces, la lib cyclops-react d'AOL (divulgation, je suis un contributeur) a des extensions pour tous les types de collections JDK , y compris List . L'interface ListX étend java.util.List et ajoute un grand nombre d'opérateurs utiles, y compris le filtre.

Vous pouvez simplement écrire-

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

ListX peut également être créé à partir d'une liste existante (via ListX.fromIterable)

Il existe une autre variante de la méthode de collecte fournie par la classe LongStream et également par les classes IntStream et DoubleStream.

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

Effectue une opération de réduction mutable sur les éléments de ce flux. Une réduction modifiable est une réduction dans laquelle la valeur réduite est un conteneur de résultat modifiable, tel qu'une liste de tableaux, et les éléments sont incorporés en mettant à jour l'état du résultat plutôt qu'en remplaçant le résultat. Cela produit un résultat équivalent à:

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

Comme réduire (long, LongBinaryOperator), les opérations de collecte peuvent être parallélisées sans nécessiter de synchronisation supplémentaire. Il s'agit d'une opération de terminal.

Et la réponse à votre question avec cette méthode de collecte est la suivante:

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

Vous trouverez ci-dessous la variante de référence de la méthode qui est assez intelligente, mais certaines sont difficiles à comprendre:

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

Ci-dessous sera la variante HashSet:

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

De même, la variante LinkedList est comme ceci:

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

Dans le cas où quelqu'un (comme moi) cherche des moyens de traiter les objets au lieu des types primitifs, utilisez 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);

impressions:

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

Voici le code d' AbacusUtil

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

Divulgation ： Je suis le développeur d'AbacusUtil.

Vous pouvez réécrire le code comme ci-dessous:

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

Pour collecter dans une liste mutable:

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

Pour collecter dans une liste immuable:

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

Explication de collectla JavaDoc :

Effectue une opération de réduction mutable sur les éléments de ce flux à l'aide d'un collecteur. Un collecteur encapsule les fonctions utilisées comme arguments à collecter (fournisseur, BiConsumer, BiConsumer), permettant la réutilisation des stratégies de collecte et la composition des opérations de collecte telles que le regroupement ou le partitionnement à plusieurs niveaux. Si le flux est parallèle et que le collecteur est simultané et que le flux n'est pas ordonné ou que le collecteur n'est pas ordonné, une réduction simultanée sera effectuée (voir Collecteur pour plus de détails sur la réduction simultanée).

Il s'agit d'une opération de terminal.

Lorsqu'ils sont exécutés en parallèle, plusieurs résultats intermédiaires peuvent être instanciés, remplis et fusionnés de manière à maintenir l'isolement des structures de données mutables. Par conséquent, même lorsqu'il est exécuté en parallèle avec des structures de données non thread-safe (telles que ArrayList), aucune synchronisation supplémentaire n'est nécessaire pour une réduction parallèle.

Si vous n'utilisez pas parallel()cela fonctionnera

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