Исполняемые доки Java: Стримы

Q: Как преобразовать стрим обратно в список в Java?

Завершите конвейер терминальным коллектором: list.stream().filter(...).collect(Collectors.toList()). В Java 16+ можно использовать более короткий .toList(), который возвращает неизменяемый список. Без терминальной операции вообще ничего не выполнится, потому что промежуточные операции вроде filter и map ленивые.

Конвейеры вместо циклов

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

Теперь, когда у вас есть лямбды, стримы встают на свои места: каждая операция принимает лямбду (или ссылку на метод), описывающую работу с одним элементом.

import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<String> names = List.of("Ada", "Boris", "Chen", "Dmitri");

        List<String> result = names.stream()
            .filter(name -> name.length() > 3)   // оставляем имена длиннее 3 символов
            .map(String::toUpperCase)            // преобразуем каждое
            .collect(Collectors.toList());       // собираем в новый список

        System.out.println(result);
    }
}

Читаем сверху вниз: взять имена, оставить длинные, перевести в верхний регистр, собрать в список. Исходный список names никогда не изменяется - стрим создаёт новый результат и оставляет источник нетронутым.

Анатомия стрима

У любого конвейера три части:

Источник - list.stream(), Arrays.stream(array) или Stream.of(a, b, c).
Ноль или более промежуточных операций - filter, map, sorted, distinct, limit. Каждая возвращает новый стрим, поэтому их можно сцеплять.
Ровно одна терминальная операция - collect, count, forEach, reduce, findFirst. Она запускает работу и выдаёт результат (или побочный эффект).

Это разделение важно из-за одного правила, которое поначалу удивляет всех.

Промежуточные операции ленивые

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

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = List.of(1, 2, 3, 4);

        nums.stream()
            .map(n -> {
                System.out.println("mapping " + n);
                return n * 2;
            });
        // Нет терминальной операции -> ничего не выводится.

        System.out.println("Done, but nothing was mapped.");
    }
}

Запустите: лямбда map ни разу не выполняется. Добавьте терминальную операцию - и вся цепочка оживает:

import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = List.of(1, 2, 3, 4);

        List<Integer> doubled = nums.stream()
            .map(n -> {
                System.out.println("mapping " + n);
                return n * 2;
            })
            .collect(Collectors.toList());   // терминальная -> теперь выполняется

        System.out.println(doubled);
    }
}

Эта ленивость - не причуда, с которой надо бороться: она позволяет стриму сливать операции и пропускать ненужную работу. Но это значит, что конвейер без терминальной операции ничего не делает, и это распространённая ошибка из разряда «почему ничего не происходит?».

filter и map: оставить и преобразовать

Эти две операции несут основную нагрузку. filter принимает Predicate (лямбду, возвращающую boolean) и оставляет элементы, которые её прошли. map принимает Function и заменяет каждый элемент результатом её применения.

import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<String> words = List.of("apple", "fig", "banana", "kiwi", "cherry");

        List<Integer> lengths = words.stream()
            .filter(w -> w.length() > 3)   // отбрасываем "fig" и "kiwi"
            .map(String::length)           // превращаем каждое слово в его длину
            .collect(Collectors.toList());

        System.out.println(lengths);   // [5, 6, 6]
    }
}

Обратите внимание, что map может менять тип элемента: здесь стрим из String становится стримом из Integer. String::length - это ссылка на метод, сокращённая запись лямбды w -> w.length().

Терминальные операции выдают результат

Когда вы придали стриму нужную форму, терминальная операция превращает его во что-то конкретное:

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = List.of(3, 1, 4, 1, 5, 9, 2, 6);

        long bigCount = nums.stream()
            .filter(n -> n > 3)
            .count();                       // сколько прошло?

        boolean anyEven = nums.stream()
            .anyMatch(n -> n % 2 == 0);     // есть ли хотя бы одно чётное?

        System.out.println("Big numbers: " + bigCount);
        System.out.println("Any even? " + anyEven);
    }
}

Распространённые терминальные операции: collect (собрать в список/множество/map), count, forEach, anyMatch / allMatch / noneMatch, findFirst, min / max и reduce. После выполнения терминальной операции стрим израсходован - повторно использовать его нельзя. Вызовите list.stream() снова, чтобы получить свежий конвейер.

Сбор результатов

collect с Collectors - главный рабочий инструмент для построения результата. Самый частый - Collectors.toList():

import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<String> names = List.of("ada", "boris", "chen");

        // Объединить в одну строку
        String joined = names.stream()
            .map(String::toUpperCase)
            .collect(Collectors.joining(", "));

        System.out.println(joined);   // ADA, BORIS, CHEN
    }
}

Collectors также даёт toSet(), joining(...), groupingBy(...) и counting(). В Java 16 и новее можно заменить collect(Collectors.toList()) на более короткий .toList() (он возвращает неизменяемый список):

List<String> result = names.stream().map(String::toUpperCase).toList();

sorted, distinct и limit

Эти промежуточные операции перестраивают стрим перед сбором:

import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = List.of(5, 3, 8, 3, 1, 9, 5, 2);

        List<Integer> top3 = nums.stream()
            .distinct()                 // убираем дубликаты
            .sorted((a, b) -> b - a)    // по убыванию
            .limit(3)                   // берём первые три
            .collect(Collectors.toList());

        System.out.println(top3);   // [9, 8, 5]
    }
}

sorted() без аргумента использует естественный порядок; передайте Comparator (здесь лямбду) для своего порядка. Comparator.reverseOrder() - более чистый способ сортировки по убыванию.

reduce: свернуть стрим в одно значение

Когда нужно объединить все элементы в один результат - сумму, произведение, самую длинную строку - reduce это универсальный инструмент. Вы передаёте ему начальное значение и функцию, которая объединяет два значения:

import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> nums = List.of(2, 4, 6, 8);

        int sum = nums.stream()
            .reduce(0, (a, b) -> a + b);   // начинаем с 0, продолжаем складывать

        int product = nums.stream()
            .reduce(1, (a, b) -> a * b);   // начинаем с 1, продолжаем умножать

        System.out.println("Sum: " + sum);
        System.out.println("Product: " + product);
    }
}

Для обычных сумм и средних значений специализированные стримы понятнее: nums.stream().mapToInt(Integer::intValue).sum(). Прибегайте к reduce, когда готового агрегатора нет.

Стримы не заменяют каждый цикл

Стримы хороши, когда вы преобразуете коллекцию в результат. Они не быстрее цикла автоматически и становятся неуклюжими, когда нужно менять внешнее состояние или замысловато прерывать выполнение. Хорошее правило: если конвейер читается как одно ясное предложение - используйте стрим; если вы тянетесь к общему счётчику или к index, обычный цикл for честнее и вполне уместен.

Помните также, что стрим одноразовый. Это выбрасывает исключение:

Stream<String> s = names.stream();
s.forEach(System.out::println);
s.count();   // IllegalStateException: stream has already been operated upon

Дальше: Optional

Несколько терминальных операций стрима - findFirst, min, max, reduce без значения-тождества - могут ничего не найти, поэтому они не возвращают «голое» значение. Они возвращают Optional - контейнер Java для «возможно значение, возможно ничего», который наконец даёт чистую альтернативу возврату null. Это следующая страница.

Часто задаваемые вопросы

Что такое стрим в Java?

Стрим - это конвейер для обработки последовательности элементов (обычно полученных из коллекции) через цепочку операций вроде filter, map и sorted, которая заканчивается терминальной операцией, например collect или count. Он не хранит данные и не изменяет источник; он описывает вычисление. Стрим создаётся с помощью list.stream(), а цепочку читают сверху вниз, как рецепт.

Как преобразовать стрим обратно в список в Java?

Завершите конвейер терминальным коллектором: list.stream().filter(...).collect(Collectors.toList()). В Java 16+ можно использовать более короткий .toList(), который возвращает неизменяемый список. Без терминальной операции вообще ничего не выполнится, потому что промежуточные операции вроде filter и map ленивые.

Когда стоит использовать стрим вместо цикла for?

Берите стрим, когда вы преобразуете или фильтруете коллекцию, получая результат - такой конвейер читается как одно ясное предложение ("взять имена, оставить длинные, перевести в верхний регистр, собрать в список"). Оставайтесь на обычном цикле for, когда нужно изменять внешнее состояние, сложным образом прерывать выполнение или когда логика проще в виде императивных шагов. Стримы про ясность, а не про чистую скорость.

Связанные концепции

Стримы в Java: filter, map, collect и reduce простыми словами