Стримы в Java 8: Полное руководство с примерами от А до Я

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

Что такое Stream API?

Stream API — это не часть коллекций и не структура данных. Это абстракция для выполнения операций над последовательностью элементов с поддержкой цепочек вызовов (pipeline) и внутренней итерации. В отличие от традиционных циклов, стримы позволяют описывать что нужно сделать, а не как это сделать.

Основные операции со стримами

Создание стримов

Стримы можно создать разными способами:

• Из коллекций: collection.stream() или collection.parallelStream()
• Из массивов: Arrays.stream(array)
• Из значений: Stream.of(1, 2, 3)
• С помощью генераторов: Stream.generate(Math::random) или Stream.iterate(0, n -> n + 2)

Промежуточные операции (Intermediate)

Эти операции возвращают новый стрим и могут быть объединены в цепочку:

1. filter(Predicate) — фильтрация элементов
2. map(Function) — преобразование элементов
3. sorted() — сортировка
4. distinct() — удаление дубликатов
5. limit(n) — ограничение количества элементов
6. skip(n) — пропуск первых n элементов

Терминальные операции (Terminal)

Завершают работу стрима и возвращают результат:

• forEach(Consumer) — выполнение действия для каждого элемента
• collect(Collector) — сбор элементов в коллекцию
• reduce() — свертка элементов
• count() — подсчет элементов
• anyMatch()/allMatch()/noneMatch() — проверка условий
• findFirst()/findAny() — поиск элементов

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

Пример 1: Фильтрация и преобразование

List names = Arrays.asList("Анна", "Борис", "Алексей", "Мария", "Артем");
List result = names.stream()
    .filter(name -> name.startsWith("А")) // Оставляем имена на "А"
    .map(String::toUpperCase) // Преобразуем в верхний регистр
    .sorted() // Сортируем
    .collect(Collectors.toList()); // Собираем в список
// Результат: [АЛЕКСЕЙ, АННА, АРТЕМ]

Пример 2: Работа с числами

List numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

// Сумма четных чисел
int sumEven = numbers.stream()
    .filter(n -> n % 2 == 0)
    .mapToInt(Integer::intValue)
    .sum();
// Результат: 30

// Максимальное нечетное число
Optional maxOdd = numbers.stream()
    .filter(n -> n % 2 != 0)
    .max(Integer::compare);
// Результат: Optional[9]

Пример 3: Группировка данных

class Person {
    String name;
    int age;
    String city;
    // конструктор и геттеры
}

List people = Arrays.asList(
    new Person("Анна", 25, "Москва"),
    new Person("Борис", 30, "Москва"),
    new Person("Алексей", 25, "Санкт-Петербург")
);

// Группировка по городу
Map> peopleByCity = people.stream()
    .collect(Collectors.groupingBy(Person::getCity));

// Группировка по городу с подсчетом
Map countByCity = people.stream()
    .collect(Collectors.groupingBy(Person::getCity, Collectors.counting()));

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

Java 8 позволяет легко распараллеливать обработку данных:

List numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

long sum = numbers.parallelStream() // Используем параллельный стрим
    .filter(n -> n % 2 == 0)
    .mapToLong(Long::valueOf)
    .sum();

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

Ленивые вычисления

Стримы используют ленивые вычисления — промежуточные операции выполняются только при вызове терминальной операции. Это позволяет оптимизировать производительность:

List names = Arrays.asList("Анна", "Борис", "Алексей");
Stream stream = names.stream()
    .filter(name -> {
        System.out.println("Фильтрация: " + name);
        return name.startsWith("А");
    })
    .map(name -> {
        System.out.println("Преобразование: " + name);
        return name.toUpperCase();
    });
// На этом этапе ничего не выведется!

// Только при вызове терминальной операции:
List result = stream.collect(Collectors.toList());
// Вывод:
// Фильтрация: Анна
// Преобразование: Анна
// Фильтрация: Борис
// Фильтрация: Алексей
// Преобразование: Алексей

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

В чем разница между Collection и Stream?

Collection хранит данные, а Stream предоставляет механизм для их обработки. Stream не хранит данные и не изменяет исходную коллекцию.

Можно ли повторно использовать стрим?

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

Когда использовать параллельные стримы?

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

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

Optional — это контейнер, который может содержать или не содержать значение. Многие терминальные операции стримов возвращают Optional, например findFirst(), max(), min().

Как обработать исключения в лямбда-выражениях стримов?

Лямбда-выражения не могут выбрасывать проверяемые исключения. Решение — обернуть исключение в RuntimeException или использовать try-catch внутри лямбды.

Какие есть ограничения у стримов?

Стримы не подходят для операций, где важен порядок обработки (кроме ordered streams), для изменяемого состояния или когда нужен доступ к индексам элементов.