Readme Russian

Несмотря на то, что Java 8 вышла уже достаточно давно, далеко не все программисты используют её новые возможности, кого-то останавливает то, что рабочие проекты слишком сложно перевести с Java 7 или даже Java 6, кого-то использование в своих проектах GWT, кто-то делает проекты под Android и не хочет или не может использовать сторонние библиотеки для реализации лямбд и Stream Api. Однако знание лямбд и Stream Api для программиста Java зачастую требуют на собеседованиях, ну и просто будет полезно при переходе на проект где используется Java 8. Я хотел бы предложить вам краткую шпаргалку по Stream Api с практическими примерами реализации различных задач с новым функциональным подходом. Знания лямбд и функционального программирования не потребуется (я постарался дать примеры так, чтобы все было понятно), уровень от самого базового знания Java и выше. Также, так как это шпаргалка, статья может использоваться, чтобы быстро вспомнить как работает та или иная особенность Java Stream Api. Краткое перечисление возможностей основных функций дано в начале статьи. Для тех кто совсем не знает что такое Stream Api Stream API это новый способ работать со структурами данных в функциональном стиле. Чаще всего с помощью stream в Java 8 работают с коллекциями, но на самом деле этот механизм может использоваться для самых различных данных. Stream Api позволяет писать обработку структур данных в стиле SQL, то если раньше задача получить сумму всех нечетных чисел из коллекции решалась следующим кодом:

Integer sumOddOld = 0; 
for(Integer i: collection) {
    if(i % 2 != 0) { 
       sumOddOld += i;
    }
} 

То с помощью Stream Api можно решить такую задачу в функциональном стиле:

Integer sumOdd = collection.stream().filter(o -> o % 2 != 0).reduce((s1, s2) -> s1 + s2).orElse(0); 
     

Более того, Stream Api позволяет решать задачу параллельно лишь изменив stream() на parallelStream() без всякого лишнего кода, т.е.

Integer sumOdd = collection.parallelStream().filter(o -> o % 2 != 0).reduce((s1, s2) -> s1 + s2).orElse(0); 

Уже делает код параллельным, без всяких семафоров, синхронизаций, рисков взаимных блокировок и т.п. Давайте начнем с начала, а именно с создания объектов stream в Java 8.

I. Способы создания стримов

Перечислим несколько способов создать стрим

1. Классический: Создание стрима из коллекции | collection.stream() | Collection collection = Arrays.asList("a1", "a2", "a3"); Stream streamFromCollection = collection.stream(); |
2. Создание стрима из значений | Stream.of(значение1, ... значениеN) Stream streamFromValues = Stream.of("a1", "a2", "a3"); |
3. Создание стрима из массива | Arrays.stream(массив) | String[] array = {"a1","a2","a3"}; Stream streamFromArrays = Arrays.stream(array); |
4. Создание стрима из файла (каждая строка в файле будет отдельным элементом в стриме) | Files.lines(путь_к_файлу) | Stream streamFromFiles = Files.lines(Paths.get("file.txt")) |
5. Создание стрима из строки | "строка".chars() | IntStream streamFromString = "123".chars() |
6. С помощью Stream.builder | Stream.builder().add(...)....build() | Stream.builder().add("a1").add("a2").add("a3").build() |
7. Создание параллельного стрима | collection.parallelStream() | Stream stream = collection.parallelStream(); |
8. Создание бесконечных стрима с помощью Stream.iterate | Stream.iterate(начальное_условие, выражение_генерации) | Stream <integer>streamFromIterate = Stream.iterate(1, n -> n + 1)</integer> |
9. Создание бесконечных стрима с помощью Stream.generate | Stream.generate(выражение_генерации) | Stream streamFromGenerate = Stream.generate(() -> "a1") |

В принципе, кроме последних двух способов создания стрима, все не отличается от обычных способов создания коллекций. Последние два способа служат для генерации бесконечных стримов, в iterate задается начальное условие и выражение получение следующего значения из предыдущего, то есть Stream.iterate(1, n -> n + 1) будет выдавать значения 1, 2, 3, 4, ... N. Stream.generate служит для генерации константных и случайных значений, он просто выдает значения соответствующие выражению, в данном примере, он будет выдавать бесконечное количество значений "a1". Для тех кто не знает лямбды Выражение n -> n + 1, это просто аналог выражения Integer func(Integer n) { return n+1;}, а выражение () -> "a1" аналог выражения String func() { return "a1";} обернутых в анонимный класс.

Подробные примеры можно найти на github'e

II. Методы работы со стримами

Java Stream API предлагает два вида методов:

1. Конвейерные - возвращают другой stream, то есть работают как builder,

2. Терминальные - возвращают другой объект, такой как коллекция, примитивы, объекты, Optional и т.д.

О том чем отличаются конвейерные и терминальные методы

Общее правило: у stream'a может быть сколько угодно вызовов конвейерных вызовов и в конце один терминальный, при этом все конвейерные методы выполняются лениво и пока не будет вызван терминальный метод никаких действий на самом деле не происходит, так же как создать объект Thread или Runnable, но не вызвать у него start. В целом, этот механизм похож на конструирования SQL запросов, может быть сколько угодно вложенных Select'ов и только один результат в итоге. Например, в выражении collection.stream().filter((s) -> s.contains("1")).skip(2).findFirst() , filter и skip - конвейерные, а findFirst - терминальный, он возвращает объект Optional и это заканчивает работу со stream'ом.

2.1 Краткое описание конвейерных методов работы со стримами

2.2 Краткое описание терминальных методов работы со стримами

Обратите внимание методы findFirst, findAny, anyMatch это short-circuiting методы, то есть обход стримов организуется таким образом чтобы найти подходящий элемент максимально быстро, а не обходить весь изначальный стрим.

2.3 Краткое описание дополнительных методов у числовых стримов

2.4 Несколько других полезных методов стримов

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

    collection.stream(). peek(...). // операция последовательна parallel().
    map(...). // операция может выполняться параллельно, 
    sequential(). reduce(...) // операция снова последовательна 

Внимание: крайне не рекомендуется использовать параллельные стримы для сколько-нибудь долгих операций (получение данных из базы, сетевых соединений), так как все параллельные стримы работают c одним пулом fork/join и такие долгие операции могут остановить работу всех параллельных стримов в JVM из-за того отсутствия доступных потоков в пуле, т.е. параллельные стримы стоит использовать лишь для коротких операций, где счет идет на миллисекунды, но не для тех где счет может идти на секунды и минуты.

III. Примеры работы с методами стримов

Рассмотрим работу с методами на различных задачах, обычно требующихся при работе с коллекциями.

3.1 Примеры использования filter, findFirst, findAny, skip, limit и count

Условие: дана коллекция строк Arrays.asList("a1", "a2", "a3", "a1"), давайте посмотрим как её можно обрабатывать используя методы filter, findFirst, findAny, skip и count:

Обратите внимание, что методы findFirst и findAny возвращают новый тип Optional, появившийся в Java 8, для того чтобы избежать NullPointerException. Метод filter удобно использовать для выборки лишь определенного множества значений, а метод skip позволяет пропускать определенное количество элементов.

Если вы не знаете лямбды: Выражение "a3"::equals это аналог boolean func(s) { return "a3".equals(s);}, а (s) -> s.contains("1") это аналог boolean func(s) { return s.contains("1");} обернутых в анонимный класс.

Условие: дана коллекция класс People (с полями name - имя, age - возраст, sex - пол), вида Arrays.asList( new People("Вася", 16, Sex.MAN), new People("Петя", 23, Sex.MAN), new People("Елена", 42, Sex.WOMEN), new People("Иван Иванович", 69, Sex.MAN)). Давайте посмотрим примеры как работать с таким классом:

Подробные примеры можно найти на github'e: про Fiter и Count операции и про Limit и Skip методы

3.2 Примеры использования distinct

Метод distinct возвращает stream без дубликатов, при этом для упорядоченного стрима (например, коллекция на основе list) порядок стабилен , для неупорядоченного - порядок не гарантируется. Рассмотрим результаты работы над коллекцией Collection ordered = Arrays.asList("a1", "a2", "a2", "a3", "a1", "a2", "a2") и Collection nonOrdered = new HashSet<>(ordered).

Обратите внимание:

1. Если вы используете distinct с классом, у которого переопределен equals, обязательно так же корректно переопределить hashCode в соответствие с контрактом equals/hashCode (самое главное чтобы hashCode для всех equals объектов, возвращал одинаковое значение), иначе distinct может не удалить дубликаты (аналогично, как при использовании HashSet/HashMap),
2. Если вы используете параллельные стримы и вам не важен порядок элементов после удаления дубликатов - намного лучше для производительности сделать сначала стрим неупорядоченным с помощь unordered(), а уже потом применять distinct(), так как подержание стабильности сортировки при параллельном стриме довольно затратно по ресурсам и distinct() на упорядоченным стриме будет выполнятся значительно дольше чем при неупорядоченном,

Подробный пример можно найти на тут

3.3 Примеры использования Match функций (anyMatch, allMatch, noneMatch)

Условие: дана коллекция строк Arrays.asList("a1", "a2", "a3", "a1"), давайте посмотрим, как её можно обрабатывать используя Match функции

Подробный пример можно найти на тут

3.4 Примеры использования Map функций (map, mapToInt, FlatMap, FlatMapToInt)

Условие: даны две коллекции collection1 = Arrays.asList("a1", "a2", "a3", "a1") и collection2 = Arrays.asList("1,2,0", "4,5"), давайте посмотрим как её можно обрабатывать используя различные map функции

Обратите внимание: все map функции могут вернуть объект другого типа (класса), то есть map может работать со стримом строк, а на выходе дать Stream из значений Integer или получать класс людей People, а возвращать класс Office, где эти люди работают и т.п., flatMap (flatMapToInt и т.п.) на выходе должны возвращать стрим с одним, несколькими или ни одним элементов для каждого элемента входящего стрима (см. последние два примера). Подробный пример можно найти на тут

3.5 Примеры использования Sorted функции

Условие: даны две коллекции коллекция строк Arrays.asList("a1", "a4", "a3", "a2", "a1", "a4") и коллекция людей класса People (с полями name - имя, age - возраст, sex - пол), вида Arrays.asList( new People("Вася", 16, Sex.MAN), new People("Петя", 23, Sex.MAN), new People("Елена", 42, Sex.WOMEN), new People("Иван Иванович", 69, Sex.MAN)). Давайте посмотрим примеры как их можно сортировать:

Так же этот пример можно найти на тут

3.6 Примеры использования Max и Min функций

Условие: дана коллекция строк Arrays.asList("a1", "a2", "a3", "a1"), и коллекция класса Peoples из прошлых примеров про Sorted и Filter функции.

Так же этот пример можно найти на тут

3.7 Примеры использования ForEach и Peek функций

Обе ForEach и Peek по сути делают одно и тоже, меняют свойства объектов в стриме, единственная разница между ними в том что ForEach терминальная и она заканчивает работу со стримом, в то время как Peek конвейерная и работа со стримом продолжается. Например, есть коллекция: Collection <stringbuilder>list = Arrays.asList(new StringBuilder("a1"), new StringBuilder("a2"), new StringBuilder("a3")); И нужно добавить к каждому элементу "_new", то для ForEach код будет list.stream().forEachOrdered((p) -> p.append("_new")); // list - содержит [a1_new, a2_new, a3_new] а для peek код будет List <stringbuilder>newList = list.stream().peek((p) -> p.append("_new")).collect(Collectors.toList()); // и list и newList содержат [a1_new, a2_new, a3_new] Пример можно найти на тут

3.8 Примеры использования Reduce функции

Метод reduce позволяет выполнять агрегатные функции на всей коллекцией (такие как сумма, нахождение минимального или максимального значение и т.п.), он возвращает одно значение для стрима, функция получает два аргумента - значение полученное на прошлых шагах и текущее значение. Условие: Дана коллекция чисел Arrays.asList(1, 2, 3, 4, 2) выполним над ними несколько действий используя reduce.

Пример можно найти на тут

3.9 Примеры использования toArray и collect функции

Если с toArray все просто, можно либо вызвать toArray() получить Object[], либо toArray(T[]::new) - получив массив типа T, то collect позволяет много возможностей преобразовать значение в коллекцию, map'у или любой другой тип. Для этого используются статические методы из Collectors, например преобразование в List будет stream.collect(Collectors.toList()). Давайте рассмотрим статические методы из Collectors:

Теперь давайте рассмотрим работу с collect и toArray на примерах: Условие: Дана коллекция чисел Arrays.asList(1, 2, 3, 4), рассмотрим работу collect и toArray с ней

Условие: Дана коллекция строк Arrays.asList("a1", "b2", "c3", "a1"), рассмотрим работу collect и toArray с ней

Также примеры можно найти на тут

3.10 Пример создания собственного Collector'a

Кроме Collector'ов уже определенных в Collectors можно так же создать собственный Collector, Давайте рассмотрим пример как его можно создать. Метод определения пользовательского Collector'a:

Collector<Тип_источника, Тип_аккумулятора, Тип_результата> сollector = Collector.of( метод_инициализации_аккумулятора, метод_обработки_каждого_элемента, метод_соединения_двух_аккумуляторов, [метод_последней_обработки_аккумулятора] ); 

Как видно из кода выше, для реализации своего Collector'a нужно определить три или четыре метода (метод_последней_обработки_аккумулятора не обязателен). Рассмотрим следующий кода, который мы писали до Java 8, чтобы объединить все строки коллекции:

StringBuilder b = new StringBuilder(); // метод_инициализации_аккумулятора 
for(String s: strings) { 
   b.append(s).append(" , "); // метод_обработки_каждого_элемента, 
} 
String joinBuilderOld = b.toString(); // метод_последней_обработки_аккумулятора 
 

И аналогичный код, который будет написан в Java 8

String joinBuilder = strings.stream().collect( Collector.of( StringBuilder::new, // метод_инициализации_аккумулятора 
(b ,s) -> b.append(s).append(" , "), // метод_обработки_каждого_элемента, 
(b1, b2) -> b1.append(b2).append(" , "), // метод_соединения_двух_аккумуляторов 
StringBuilder::toString // метод_последней_обработки_аккумулятора ) ); 

В общем-то, три метода легко понять из кода выше, их мы писали практически при каждой обработки коллекций, но вот что такое метод_соединения_двух_аккумуляторов? Это метод который нужен для параллельной обработки Collector'a, в данном случае при параллельном стриме коллекция может быть разделенной на две части (или больше частей), в каждой из которых будет свой аккумулятор StringBuilder и потом необходимо будет их объединить, то код до Java 8 при 2 потоках будет таким:

StringBuilder b1 = new StringBuilder(); // метод_инициализации_аккумулятора_1 
for(String s: stringsPart1) { // stringsPart1 - первая часть коллекции 
   strings b1.append(s).append(" , "); // метод_обработки_каждого_элемента, 
} 
StringBuilder b2 = new StringBuilder(); // метод_инициализации_аккумулятора_2 
for(String s: stringsPart2) { // stringsPart2 - вторая часть коллекции 
   strings b2.append(s).append(" , "); // метод_обработки_каждого_элемента, 
} 
StringBuilder b = b1.append(b2).append(" , "), // метод_соединения_двух_аккумуляторов 
String joinBuilderOld = b.toString(); // метод_последней_обработки_аккумулятора 

Напишем свой аналог

Collectors.toList() для работы со строковым стримом:  // Напишем свой аналог toList 
Collector<string, list<string="">, List> toList = Collector.of( ArrayList::new, // метод инициализации аккумулятора 
List::add, // метод обработки каждого элемента 
(l1, l2) -> { l1.addAll(l2); return l1; } // метод соединения двух аккумуляторов при параллельном выполнении );
// Используем его для получение списка строк без дубликатов из стрима 
List distinct1 = strings.stream().distinct().collect(toList); 

Так же примеры можно найти на тут

IV. Заключение

Вот и все. Надеюсь, моя небольшая шпаргалка по работе со stream api была для вас полезной. Все исходники есть на github'е, удачи в написании хорошего кода.

P.S. Список других статей, где можно прочитать дополнительно про Stream Api:

1. Processing Data with Java SE 8 Streams, Part 1 от Oracle,

2. Processing Data with Java SE 8 Streams, Part 2 от Oracle,

3. Полное руководство по Java 8 Stream