1. Stream

Stream — это объект для универсальной работы с данными. Мы указываем, какие операции хотим провести, при этом не заботясь о деталях реализации. Например, взять элементы из списка сотрудников, выбрать тех, кто младше 40 лет, отсортировать по фамилии и поместить в новый список. Или чуть сложнее, прочитать все json-файлы, находящиеся в папке books, десериализировать в список объектов книг, обработать элементы всех этих списков, а затем сгруппировать книги по автору.

Данные могут быть получены из источников, коими являются коллекции или методы, поставляющие данные. Например, список файлов, массив строк, метод range() для числовых промежутков и т.д. То есть, стрим использует существующие коллекции для получения новых элементов, это ни в коем случае не новая структура данных.
К данным затем применяются операторы. Например, взять лишь некоторые элементы (filter), преобразовать каждый элемент (map), посчитать сумму элементов или объединить всё в один объект (reduce).

Операторы можно разделить на две группы:
     - Промежуточные (intermediate) — обрабатывают поступающие элементы и возвращают стрим. Промежуточных операторов в цепочке обработки элементов может быть много.
     - Терминальные (terminal) — обрабатывают элементы и завершают работу стрима, так что терминальный оператор в цепочке может быть только один.

2. Получение объекта Stream

Пока что хватит теории. Пришло время посмотреть, как создать или получить объект java.util.stream.Stream.
  - Пустой стрим: Stream.empty() // Stream<String>
  - Стрим из List: list.stream() // Stream<String>
  - Стрим из Map: map.entrySet().stream() // Stream<Map.Entry<String, String>>
  - Стрим из массива: Arrays.stream(array) // Stream<String>
  - Стрим из указанных элементов: Stream.of("a", "b", "c") // Stream<String>

А вот и пример:

1. public static void main(String[] args) {
2.     List<String> list = Arrays.stream(args)
3.         .filter(s -> s.length() <= 2)
4.         .collect(Collectors.toList());
5. }

В данном примере источником служит метод Arrays.stream, который из массива args делает стрим. Промежуточный оператор filter отбирает только те строки, длина которых не превышает два. Терминальный оператор collect собирает полученные элементы в новый список.

И ещё один пример:

1. IntStream.of(120, 410, 85, 32, 314, 12)
2.     .filter(x -> x < 300)
3.     .map(x -> x + 11)
4.     .limit(3)
5.     .forEach(System.out::print)

десь уже три промежуточных оператора:
  - filter — отбирает элементы, значение которых меньше 300,
  - map — прибавляет 11 к каждому числу,
  - limit — ограничивает количество элементов до 3.

Терминальный оператор forEach применяет функцию print к каждому приходящему элементу.

На ранних версиях Java этот пример выглядел бы так:

1. int[] arr = {120, 410, 85, 32, 314, 12};
2. int count = 0;
3. for (int x : arr) {
4.     if (x >= 300) continue;
5.     x += 11;
6.     count++;
7.     if (count > 3) break;
8.     System.out.print(x);
9. }

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

3. Как работает стрим

У стримов есть некоторые особенности. Во-первых, обработка не начнётся до тех пор, пока не будет вызван терминальный оператор. list.stream().filter(x -> x > 100); не возьмёт ни единого элемента из списка. Во-вторых, стрим после обработки нельзя переиспользовать.

1. Stream<String> stream = list.stream();
2. stream.forEach(System.out::println);
3. stream.filter(s -> s.contains("Stream API"));
4. stream.forEach(System.out::println);

Код на второй строке выполнится, а вот на третьей выбросит исключение java.lang.IllegalStateException: stream has already been operated upon or closed.

Исходя из первой особенности, делаем вывод, что обработка происходит от терминального оператора к источнику. Это действительно так и это удобно. Мы можем в качестве источника использовать генерируемую бесконечную последовательность, скажем, факториала или чисел Фибоначчи, но обрабатывать лишь некоторую её часть

КПока мы не присоединили терминальный оператор, доступа к источнику не проводилось. Как только появился терминальный оператор forEach, он стал запрашивать элементы у стоящего перед ним оператора limit. Тот в свою очередь обращается к map, map к filter, а filter уже обращается к источнику. Затем элементы поступают в прямом порядке: источник, filter, map, limit и forEach.
Пока какой-либо из операторов не обработает элемент должным образом, новые запрошены не будут.
Как только через оператор limit прошло 3 элемента, он переходит в закрытое состояние и больше не будет запрашивать элементы у map. forEach запрашивает очередной элемент, но limit сообщает, что больше не может поставить элементов, поэтому forEach делает вывод, что элементы закончились и прекращает работу.

Такой подход зовётся pull iteration, то есть элементы запрашиваются у источника по мере надобности. К слову, в RxJava реализован push iteration подход, то есть источник сам уведомляет, что появились элементы и их нужно обработать.

4. Параллельные стримы

Стримы бывают последовательными (sequential) и параллельными (parallel). Последовательные выполняются только в текущем потоке, а вот параллельные используют общий пулForkJoinPool.commonPool(). При этом элементы разбиваются (если это возможно) на несколько групп и обрабатываются в каждом потоке отдельно. Затем на нужном этапе группы объединяются в одну для предоставления конечного результата.

Чтобы получить параллельный стрим, нужно либо вызвать метод parallelStream() вместо stream(), либо превратить обычный стрим в параллельный, вызвав промежуточный оператор parallel.

1. list.parallelStream()
2.     .filter(x -> x > 10)
3.     .map(x -> x * 2)
4.     .collect(Collectors.toList());
6. IntStream.range(0, 10)
7.     .parallel()
8.     .map(x -> x * 10)
9.     .sum();

Работа с потоконебезопасными коллекциями, разбиение элементов на части, создание потоков, объединение частей воедино, всё это кроется в реализации Stream API. От нас лишь требуется вызвать нужный метод и проследить, чтобы функции в операторах не зависели от каких-либо внешних факторов, иначе есть риск получить неверный результат или ошибку.

Вот так делать нельзя:

1. final List<Integer> ints = new ArrayList<>();
2. IntStream.range(0, 1000000)
3.     .parallel()
4.     .forEach(i -> ints.add(i));
5. System.out.println(ints.size());

Это код Шрёдингера. Он может нормально выполниться и показать 1000000, может выполниться и показать 869877, а может и упасть с ошибкой Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 332 at java.util.ArrayList.add(ArrayList.java:459).

Поэтому разработчики настоятельно просят воздержаться от побочных эффектов в лямбдах, то тут, то там говоря в документации о невмешательстве (non-interference).

5. Стримы для примитивов

Кроме объектных стримов Stream<T>, существуют специальные стримы для примитивных типов:
  - IntStream для int,
  - LongStream для long,
  - DoubleStream для double.

Для boolean, byte, short и char специальных стримов не придумали, но вместо них можно использовать IntStream, а затем приводить к нужному типу. Для float тоже придётся воспользоваться DoubleStream.

Примитивные стримы полезны, так как не нужно тратить время на боксинг/анбоксинг, к тому же у них есть ряд специальных операторов, упрощающих жизнь. Их мы рассмотрим очень скоро.

6. Операторы Stream API

Дальше приводятся операторы Stream API с описанием, демонстрацией и примерами. Можете использовать это как справочник.

6.1. Источники

empty()

Стрим, как и коллекция, может быть пустым, а значит всем последующем операторам нечего будет обрабатывать.

1. Stream.empty()
2.     .forEach(System.out::println);
3. // Вывода нет

---

of(T value)
of(T... values)

Стрим для одного или нескольких перечисленных элементов. Очень часто вижу, что используют такую конструкцию:

1. Arrays.asList(1, 2, 3).stream()
2.     .forEach(System.out::println);

однако она излишня. Вот так проще:

1. Stream.of(1, 2, 3)
2.     .forEach(System.out::println);

---

ofNullable(T t)

Появился в Java 9. Возвращает пустой стрим, если в качестве аргумента передан null, в противном случае, возвращает стрим из одного элемента.

[копировать] [скачать]

1. String str = Math.random() > 0.5 ? "I'm feeling lucky" : null;
2. Stream.ofNullable(str)
3.     .forEach(System.out::println);

---

generate(Supplier s)

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

1. Stream.generate(() -> 6)
2.     .limit(6)
3.     .forEach(System.out::println);
4. // 6, 6, 6, 6, 6, 6

Поскольку стрим бесконечный, нужно его ограничивать или осторожно использовать, дабы не попасть в бесконечный цикл.

---

iterate​(T seed, UnaryOperator f)

Возвращает бесконечный стрим с элементами, которые образуются в результате последовательного применения функции f к итерируемому значению. Первым элементом будет seed, затем f(seed), затем f(f(seed)) и так далее.

1. Stream.iterate(2, x -> x + 6)
2.     .limit(6)
3.     .forEach(System.out::println);
4. // 2, 8, 14, 20, 26, 32

1. Stream.iterate(1, x -> x * 2)
2.     .limit(6)
3.     .forEach(System.out::println);
4. // 1, 2, , , , 32

---

iterate​(T seed, Predicate hasNext, UnaryOperator f)

Появился в Java 9. Всё то же самое, только добавляется ещё один аргумент hasNext: если он возвращает false, то стрим завершается. Это очень похоже на цикл for:

1. for (i = seed; hasNext(i); i = f(i)) {
2. }

Таким образом, с помощью iterate теперь можно создать конечный стрим.

1. Stream.iterate(2, x -> x < 25, x -> x + 6)
2.     .forEach(System.out::println);
3. // 2, 8, 14, 20

1. Stream.iterate(4, x -> x < 100, x -> x * 4)
2.     .forEach(System.out::println);
3. // , 16, 

concat(Stream a, Stream b)

Объединяет два стрима так, что вначале идут элементы стрима A, а по его окончанию последуют элементы стрима B.

[копировать] [скачать]

1. Stream.concat(
2.         Stream.of(1, 2, 3),
3.         Stream.of(4, 5, 6))
4.     .forEach(System.out::println);
5. // 1, 2, 3, 4, 5, 6

1. Stream.concat(
2.         Stream.of(10),
3.         Stream.of(, ))
4.     .forEach(System.out::println);
5. // 10, 4, 16

builder()

Создаёт мутабельный объект для добавления элементов в стрим без использования какого-либо контейнера для этого.

[копировать] [скачать]

1. Stream.Builder<Integer> streamBuider = Stream.<Integer>builder()
2.         .add(0)
3.         .add(1);
4. for (int i = 2; i <= 8; i += 2) {
5.     streamBuider.accept(i);
6. }
7. streamBuider
8.     .add(9)
9.     .add(10)
10.     .build()
11.     .forEach(System.out::println);
12. // 0, 1, 2, 4, 6, 8, 9, 10

---

IntStream.range​(int startInclusive, int endExclusive)
LongStream.range​(long startInclusive, long endExclusive)

Создаёт стрим из числового промежутка [start..end), то есть от start (включительно) по end.

[копировать] [скачать]

1. IntStream.range(0, 10)
2.     .forEach(System.out::println);
3. // 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
5. LongStream.range(-10L, -5L)
6.     .forEach(System.out::println);
7. // -10, -9, -8, -7, -6

---

IntStream.rangeClosed​(int startInclusive, int endInclusive)
LongStream.range​Closed(long startInclusive, long endInclusive)

Создаёт стрим из числового промежутка [start..end], то есть от start (включительно) по end (включительно).

[копировать] [скачать]

1. IntStream.rangeClosed(0, 5)
2.     .forEach(System.out::println);
3. // 0, 1, 2, 3, 4, 5
5. LongStream.range(-8L, -5L)
6.     .forEach(System.out::println);
7. // -8, -7, -6, -5

6.2. Промежуточные операторы

filter​(Predicate predicate)

Фильтрует стрим, принимая только те элементы, которые удовлетворяют заданному условию.

[копировать] [скачать]

1. Stream.of(1, 2, 3)
2.     .filter(x -> x == 10)
3.     .forEach(System.out::print);
4. // Вывода нет, так как после фильтрации стрим станет пустым
6. Stream.of(120, 410, 85, 32, 314, 12)
7.     .filter(x -> x > 100)
8.     .forEach(System.out::println);
9. // 120, 410, 314

1. IntStream.range(2, 9)
2.     .filter(x -> x %  == 0)
3.     .forEach(System.out::println);
4. // 3, 6

map​(Function mapper)

Применяет функцию к каждому элементу и затем возвращает стрим, в котором элементами будут результаты функции. map можно применять для изменения типа элементов.

Stream.mapToDouble​(ToDoubleFunction mapper)
Stream.mapToInt​(ToIntFunction mapper)
Stream.mapToLong​(ToLongFunction mapper)
IntStream.mapToObj(IntFunction mapper)
IntStream.mapToLong(IntToLongFunction mapper)
IntStream.mapToDouble(IntToDoubleFunction mapper)

Специальные операторы для преобразования объектного стрима в примитивный, примитивного в объектный, либо примитивного стрима одного типа в примитивный стрим другого.

[копировать] [скачать]

1. Stream.of("3", "4", "5")
2.     .map(Integer::parseInt)
3.     .map(x -> x + 10)
4.     .forEach(System.out::println);
5. // 13, 14, 15
7. Stream.of(120, 410, 85, 32, 314, 12)
8.     .map(x -> x + 11)
9.     .forEach(System.out::println);
10. // 131, 421, 96, 43, 325, 23

1. Stream.of("10", "11", "")
2.     .map(x -> Integer.parseInt(x, 16))
3.     .forEach(System.out::println);
4. // , , 50

flatMap​(Function<T, Stream<R>> mapper)

Один из самых интересных операторов. Работает как map, но с одним отличием — можно преобразовать один элемент в ноль, один или множество других.

flatMapToDouble​(Function mapper)
flatMapToInt​(Function mapper)
flatMapToLong​(Function mapper)

Как и в случае с map, служат для преобразования в примитивный стрим.

Для того, чтобы один элемент преобразовать в ноль элементов, нужно вернуть null, либо пустой стрим. Чтобы преобразовать в один элемент, нужно вернуть стрим из одного элемента, например, через Stream.of(x). Для возвращения нескольких элементов, можно любыми способами создать стрим с этими элементами.

[копировать] [скачать]

1. Stream.of(2, 3, 0, 1, 3)
2.     .flatMap(x -> IntStream.range(0, x))
3.     .forEach(System.out::println);
4. // 0, 1, 0, 1, 2, 0, 0, 1, 2

1. Stream.of(1, 2, 3, 4, 5, 6)
2.     .flatMap(x -> {
3.          switch (x % ) {
4.              case 0:
5.                  return Stream.of(x, x*x, x*x*);
6.              case 1:
7.                  return Stream.of(x);
8.              case 2:
9.              default:
10.                  return Stream.empty();
11.          }
12.      })
13.     .forEach(System.out::println);
14. // 1, 3, 9, 18, 4, 6, 36, 72

limit​(long maxSize)

Ограничивает стрим maxSize элементами.

[копировать] [скачать]

1. Stream.of(120, 410, 85, 32, 314, 12)
2.     .limit(4)
3.     .forEach(System.out::println);
4. // 120, 410, 85, 32

1. Stream.of(120, 410, 85, 32, 314, 12)
2.     .limit()
3.     .limit(5)
4.     .forEach(System.out::println);
5. // 120, 410
7. Stream.of(19)
8.     .limit()
9.     .forEach(System.out::println);
10. // Вывода нет

skip​(long n)

Пропускает n элементов стрима.

[копировать] [скачать]

1. Stream.of(5, 10)
2.     .skip(40)
3.     .forEach(System.out::println);
4. // Вывода нет
6. Stream.of(120, 410, 85, 32, 314, 12)
7.     .skip(2)
8.     .forEach(System.out::println);
9. // 85, 32, 314, 12

1. IntStream.range(0, 10)
2.     .limit(5)
3.     .skip(3)
4.     .forEach(System.out::println);
5. // , 
7. IntStream.range(0, 10)
8.     .skip(5)
9.     .limit(3)
10.     .skip(1)
11.     .forEach(System.out::println);
12. // , 

sorted​()
sorted​(Comparator comparator)

Сортирует элементы стрима. Причём работает этот оператор очень хитро: если стрим уже помечен как отсортированный, то сортировка проводиться не будет, иначе соберёт все элементы, отсортирует их и вернёт новый стрим, помеченный как отсортированный. См. 9.1.

[копировать] [скачать]

1. IntStream.range(0, 100000000)
2.     .sorted()
3.     .limit(3)
4.     .forEach(System.out::println);
5. // 0, 1, 2
7. IntStream.concat(
8.         IntStream.range(0, 100000000),
9.         IntStream.of(-1, -2))
10.     .sorted()
11.     .limit(3)
12.     .forEach(System.out::println);
13. // Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
15. Stream.of(120, 410, 85, 32, 314, 12)
16.     .sorted()
17.     .forEach(System.out::println);
18. // 12, 32, 85, 120, 314, 410

1. Stream.of(120, 410, 85, 32, 314, 12)
2.     .sorted(Comparator.Order())
3.     .forEach(System.out::println);
4. // 410, 314, 120, 85, 32, 12

distinct​()

Убирает повторяющиеся элементы и возвращаем стрим с уникальными элементами. Как и в случае с sorted, смотрит, состоит ли уже стрим из уникальных элементов и если это не так, отбирает уникальные и помечает стрим как содержащий уникальные элементы.

1. Stream.of(2, 1, 8, 1, 3, 2)
2.     .distinct​()
3.     .forEach(System.out::println);
4. // 2, 1, 8, 3

1. IntStream.concat(
2.         IntStream.range(2, 5),
3.         IntStream.range(0, 4))
4.     .distinct()
5.     .forEach(System.out::println);
6. // , , , , 

peek​(Consumer action)

Выполняет действие над каждым элементом стрима и при этом возвращает стрим с элементами исходного стрима. Служит для того, чтобы передать элемент куда-нибудь, не разрывая при этом цепочку операторов (вы же помните, что forEach — терминальный оператор и после него стрим завершается?), либо для отладки.

[копировать] [скачать]

1. Stream.of(0, 3, 0, 0, 5)
2.     .peek(x -> System.out.format("before distinct: %d%n", x))
3.     .distinct()
4.     .peek(x -> System.out.format("after distinct: %d%n", x))
5.     .map(x -> x * x)
6.     .forEach(x -> System.out.format("after map: %d%n", x));
7. // before distinct: 0
8. // after distinct: 0
9. // after map: 0
10. // before distinct: 3
11. // after distinct: 3
12. // after map: 9
13. // before distinct: 1
14. // after distinct: 1
15. // after map: 1
16. // before distinct: 5
17. // before distinct: 0
18. // before distinct: 5
19. // after distinct: 5
20. // after map: 25

takeWhile​(Predicate predicate)

Появился в Java 9. Возвращает элементы до тех пор, пока они удовлетворяют условию, то есть функция-предикат возвращает true. Это как limit, только не с числом, а с условием.

1. Stream.of(1, 2, 3, 4, 2, 5)
2.     .takeWhile(x -> x < 3)
3.     .forEach(System.out::println);
4. // 1, 2

1. IntStream.range(2, 7)
2.     .takeWhile(x -> x != )
3.     .forEach(System.out::println);
4. // 2, 3, 4

dropWhile​(Predicate predicate)

Появился в Java 9. Пропускает элементы до тех пор, пока они удовлетворяют условию, затем возвращает оставшуюся часть стрима. Если предикат вернул для первого элемента false, то ни единого элемента не будет пропущено. Оператор подобен skip, только работает по условию.

[копировать] [скачать]

1. Stream.of(1, 2, 3, 4, 2, 5)
2.     .dropWhile(x -> x >= 3)
3.     .forEach(System.out::println);
4. // 1, 2, 3, 4, 2, 5
6. Stream.of(1, 2, 3, 4, 2, 5)
7.     .dropWhile(x -> x < 3)
8.     .forEach(System.out::println);
9. // 3, 4, 2, 5

1. IntStream.range(2, 7)
2.     .dropWhile(x -> x < )
3.     .forEach(System.out::println);
4. // 5, 6
6. IntStream.of(1, 3, 2, 0, 5, 4)
7.     .dropWhile(x -> x  2 == 1)
8.     .forEach(System.out::println);
9. // 2, 0, 5, 6

boxed()

Преобразует примитивный стрим в объектный.

[копировать] [скачать]

1. DoubleStream.of(0.1, Math.PI)
2.     .boxed()
3.     .map(Object::getClass)
4.     .forEach(System.out::println);
5. // class java.lang.Double
6. // class java.lang.Double

6.3. Терминальные операторы

void forEach​(Consumer action)

Выполняет указанное действие для каждого элемента стрима.

[копировать] [скачать]

1. Stream.of(120, 410, 85, 32, 314, 12)
2.     .forEach(x -> System.out.format("%s, ", x));
3. // 120, 410, 85, 32, 314, 12

void forEachOrdered​(Consumer action)

Тоже выполняет указанное действие для каждого элемента стрима, но перед этим добивается правильного порядка вхождения элементов. Используется для параллельных стримов, когда нужно получить правильную последовательность элементов.

[копировать] [скачать]

1. IntStream.range(0, 100000)
2.     .parallel()
3.     .filter(x -> x % 10000 == 0)
4.     .map(x -> x / 10000)
5.     .forEach(System.out::println);
6. // 5, 6, 7, 3, 4, 8, 0, 9, 1, 2
8. IntStream.range(0, 100000)
9.     .parallel()
10.     .filter(x -> x % 10000 == 0)
11.     .map(x -> x / 10000)
12.     .forEachOrdered(System.out::println);
13. // 0, 1, 2, 3, 4, 5, 6, 7, 8, 9

---

long count​()

Возвращает количество элементов стрима.

[копировать] [скачать]

1. long count = IntStream.range(0, 10)
2.     .flatMap(x -> IntStream.range(0, x))
3.     .count();
4. System.out.println(count);
5. // 45
7. System.out.println(
8.     IntStream.rangeClosed(-3, )
9.         .count()
10. );
11. // 10
13. System.out.println(
14.     Stream.of(0, 2, 9, 13, 5, 11)
15.         .(x -> x  2)
16.         .filter(x -> x % 2 == 1)
17.         .count()
18. );
19. // 0

---

R collect​(Collector collector)

Один из самых мощных операторов Stream API. С его помощью можно собрать все элементы в список, множество или другую коллекцию, сгруппировать элементы по какому-нибудь критерию, объединить всё в строку и т.д.. В классе java.util.stream.Collectors очень много методов на все случаи жизни, мы рассмотрим их позже. При желании можно написать свой коллектор, реализовав интерфейс Collector.

[копировать] [скачать]

1. List<Integer> list = Stream.of(1, 2, 3)
2.     .collect(Collectors.toList());
3. // list: [1, 2, 3]
5. String s = Stream.of(1, 2, 3)
6.     .map(String::valueOf)
7.     .collect(Collectors.joining("-", "<", ">"));
8. // s: "<1-2-3>"

R collect​(Supplier supplier, BiConsumer accumulator, BiConsumer combiner)

То же, что и collect(collector), только параметры разбиты для удобства. Если нужно быстро сделать какую-то операцию, нет нужды реализовывать интерфейс Collector, достаточно передать три лямбда-выражения.

supplier должен поставлять новые объекты (контейнеры), например new ArrayList(), accumulator добавляет элемент в контейнер, combiner необходим для параллельных стримов и объединяет части стрима воедино.

[копировать] [скачать]

1. List<String> list = Stream.of("a", "b", "c", "d")
2.     .collect(ArrayList::new, ArrayList::add, ArrayList::addAll);
3. // list: ["a", "b", "c", "d"]

---

Object[] toArray​()

Возвращает нетипизированный массив с элементами стрима.

A[] toArray​(IntFunction<A[]> generator)
Аналогично, только возвращает типизированный массив.

[копировать] [скачать]

1. String[] elements = Stream.of("a", "b", "c", "d")
2.     .toArray(String[]::new);
3. // elements: ["a", "b", "c", "d"]

---

T reduce​(T identity, BinaryOperator accumulator)
U reduce​(U identity, BiFunction accumulator, BinaryOperator combiner)

Ещё один полезный оператор. Позволяет преобразовать все элементы стрима в один объект. Например, посчитать сумму всех элементов, либо найти минимальный элемент.

Сперва берётся объект identity и первый элемент стрима, применяется функция accumulator и identity становится её результатом. Затем всё продолжается для остальных элементов.

1. int sum = Stream.of(1, 2, 3, 4, 5)
2.     .reduce(10, (acc, x) -> acc + x);
3. // sum: 25

Optional reduce​(BinaryOperator accumulator)

Этот метод отличается тем, что у него нет начального объекта identity. В качестве него служит первый элемент стрима. Поскольку стрим может быть пустой и тогда identity объект не присвоится, то результатом функции служит Optional, позволяющий обработать и эту ситуацию, вернув Optional.empty().

[копировать] [скачать]

1. Optional<Integer> result = Stream.<Integer>empty()
2.     .reduce((acc, x) -> acc + x);
3. System.out.println(result.isPresent());
4. // false
6. Optional<Integer> sum = Stream.of(1, 2, 3, 4, 5)
7.     .reduce((acc, x) -> acc + x);
8. System.out.println(sum.get());
9. // 15

1. int sum = IntStream.of(2, 4, 6, 8)
2.     .reduce(, (acc, x) -> acc + x);
3. // sum: 25
5. int product = IntStream.range(0, 10)
6.     .filter(x -> x++ % 4 == 0)
7.     .reduce((acc, x) -> acc * x)
8.     .getAsInt();
9. // product: 

Optional min​(Comparator comparator)

Optional max​(Comparator comparator)

Поиск минимального/максимального элемента, основываясь на переданном компараторе. Внутри вызывается reduce:

[копировать] [скачать]

1. reduce((a, b) -> comparator.compare(a, b) <= 0 ? a : b));
2. reduce((a, b) -> comparator.compare(a, b) >= 0 ? a : b));

[копировать] [скачать]

1. int min = Stream.of(20, 11, 45, 78, 13)
2.     .min(Integer::compare).get();
3. // min: 11
5. int max = Stream.of(20, 11, 45, 78, 13)
6.     .max(Integer::compare).get();
7. // max: 78

---

Optional findAny​()

Возвращает первый попавшийся элемент стрима. В параллельных стримах это может быть действительно любой элемент, который лежал в разбитой части последовательности.

Optional findFirst​()

Гарантированно возвращает первый элемент стрима, даже если стрим параллельный.

Если нужен любой элемент, то для параллельных стримов быстрее будет работать findAny().

[копировать] [скачать]

1. int anySeq = IntStream.range(4, 65536)
2.     .findAny()
3.     .getAsInt();
4. // anySeq: 4
6. int firstSeq = IntStream.range(4, 65536)
7.     .findFirst()
8.     .getAsInt();
9. // firstSeq: 4
11. int anyParallel = IntStream.range(4, 65536)
12.     .parallel()
13.     .findAny()
14.     .getAsInt();
15. // anyParallel: 32770
17. int firstParallel = IntStream.range(4, 65536)
18.     .parallel()
19.     .findFirst()
20.     .getAsInt();
21. // firstParallel: 4

---

boolean allMatch​(Predicate predicate)

Возвращает true, если все элементы стрима удовлетворяют условию predicate. Если встречается какой-либо элемент, для которого результат вызова функции-предиката будет false, то оператор перестаёт просматривать элементы и возвращает false.

1. boolean result = Stream.of(1, 2, 3, 4, 5)
2.     .allMatch(x -> x <= 7);
3. // result: true

1. boolean result = Stream.of(1, 2, 3, 4, 5)
2.     .allMatch(x -> x < 3);
3. // result: false

1. boolean result = Stream.of(120, 410, 85, 32, 314, 12)
2.     .allMatch(x -> x % 2 == 0);
3. // result: 

boolean anyMatch​(Predicate predicate)

Возвращает true, если хотя бы один элемент стрима удовлетворяет условию predicate. Если такой элемент встретился, нет смысла продолжать перебор элементов, поэтому сразу возвращается результат.

1. boolean result = Stream.of(1, 2, 3, 4, 5)
2.     .anyMatch(x -> x == 3);
3. // result: true

1. boolean result = Stream.of(1, 2, 3, 4, 5)
2.     .anyMatch(x -> x == 8);
3. // result: false

1. boolean result = Stream.of(120, 410, 85, 32, 314, 12)
2.     .anyMatch(x -> x % 22 == 0);
3. // result: 

boolean noneMatch​(Predicate predicate)

Возвращает true, если, пройдя все элементы стрима, ни один не удовлетворил условию predicate. Если встречается какой-либо элемент, для которого результат вызова функции-предиката будет true, то оператор перестаёт перебирать элементы и возвращает false.

1. boolean result = Stream.of(1, 2, 3, 4, 5)
2.     .noneMatch(x -> x == 9);
3. // result: true

оператор перестаёт перебирать элементы и возвращает false.

1. boolean result = Stream.of(1, 2, 3, 4, 5)
2.     .noneMatch(x -> x == 9);
3. // result: true

1. boolean result = Stream.of(1, 2, 3, 4, 5)
2.     .noneMatch(x -> x == 3);
3. // result: false

ьььь