Получение списка из java.util.stream.Stream в Java 8

Я играл с лямбдами Java 8, чтобы легко фильтровать коллекции. Но я не нашел краткий способ получить результат в виде нового списка в том же утверждении. Вот мой самый лаконичный подход:

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

Примеры в сети не ответили на мой вопрос, потому что они останавливаются без создания нового списка результатов. Должен быть более лаконичный способ. Я бы ожидал, что Streamкласс имеет методы , как toList(), toSet()...

Есть ли способ, которым переменные targetLongListмогут быть непосредственно назначены третьей строкой?

То, что вы делаете, может быть самым простым способом, при условии, что ваш поток остается последовательным - в противном случае вам придется предварительно вызвать вызов sequential () forEach.

[позднее редактирование: причина, по которой вызов sequential () необходим, заключается в том, что код в том виде, в котором он стоит ( forEach(targetLongList::add)), был бы нечетким, если бы поток был параллельным. Даже в этом случае не будет достигнут ожидаемый эффект, поскольку forEachон явно недетерминирован - даже в последовательном потоке порядок обработки элементов не гарантируется. Вы должны использовать forEachOrderedдля обеспечения правильного заказа. Целью разработчиков Stream API является то, что вы будете использовать коллектор в этой ситуации, как показано ниже.]

Альтернатива

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

Обновлено:

Другой подход заключается в использовании Collectors.toList:

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

Предыдущее решение:

Другой подход заключается в использовании Collectors.toCollection:

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

Мне нравится использовать метод util, который возвращает коллектор, ArrayListкогда это то, что я хочу.

Я думаю, что использование решения Collectors.toCollection(ArrayList::new)немного слишком шумно для такой обычной операции.

Пример:

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

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

Этим ответом я также хочу продемонстрировать, насколько просто создавать и использовать пользовательские коллекторы, что в целом очень полезно.

Если у вас есть массив примитивов, вы можете использовать коллекции примитивов, доступные в Eclipse Collections .

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

Если вы не можете изменить sourceLongList с 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<>());

Если вы хотите использовать 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);

Примечание: я участвую в коллекциях Eclipse.

Немного более эффективный способ (избегайте создания исходного списка и автоматической распаковки с помощью фильтра):

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

collect(Collectors.toList());

Это вызов, который вы можете использовать для преобразования любого потока в список.

более конкретно:

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

от:

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

Если вы не возражаете против использования сторонних библиотек, в библиотеке AOL cyclops-реагировать (раскрытие которой я участвую) есть расширения для всех типов JDK Collection , включая List . Интерфейс ListX расширяет java.util.List и добавляет большое количество полезных операторов, включая фильтр.

Вы можете просто написать

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

ListX также может быть создан из существующего списка (через ListX.fromIterable)

Существует еще один вариант метода сбора данных, предоставляемый классом LongStream, а также классами IntStream и DoubleStream.

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

Выполняет изменяемую операцию сокращения над элементами этого потока. Изменяемое сокращение - это такое, в котором уменьшенное значение представляет собой изменяемый контейнер результатов, такой как ArrayList, и элементы включаются путем обновления состояния результата, а не путем замены результата. Это дает результат, эквивалентный:

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

Как и Reduce (long, LongBinaryOperator), операции сбора могут быть распараллелены без дополнительной синхронизации. Это терминальная операция.

И ответ на ваш вопрос с этим методом сбора, как показано ниже:

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

Ниже приведен вариант справочника по методам, который довольно умен, но несколько сложен для понимания:

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

Ниже будет вариант HashSet:

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

Аналогично вариант LinkedList выглядит так:

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

Если кто-то (например, я) ищет способы взаимодействия с объектами вместо примитивных типов, тогда используйте 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);

печатает:

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

Вот код от AbacusUtil

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

Раскрытие информации: я разработчик AbacusUtil.

Вы можете переписать код, как показано ниже:

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

Чтобы собрать в изменяемый список:

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

Собрать в неизменном списке:

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

Объяснение collectиз JavaDoc :

Выполняет изменяемую операцию сокращения над элементами этого потока, используя Collector. Collector содержит функции, используемые в качестве аргументов для сбора (Supplier, BiConsumer, BiConsumer), что позволяет повторно использовать стратегии сбора и составления операций сбора, таких как многоуровневое группирование или разбиение. Если поток параллельный, а коллектор является параллельным, или поток неупорядочен, или коллектор неупорядочен, то будет выполнено параллельное сокращение (см. Collector для получения подробной информации о параллельном сокращении).

Это терминальная операция.

При параллельном выполнении несколько промежуточных результатов могут быть созданы, заполнены и объединены для обеспечения изоляции изменяемых структур данных. Следовательно, даже при параллельном выполнении с не поточно-ориентированными структурами данных (такими как ArrayList) дополнительная синхронизация не требуется.

Если вы не используете parallel()это будет работать

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