Как работает Stream API? В чём разница между промежуточными и терминальными операциями?

Пример пайплайна

import java.util.*;
import java.util.stream.*;

record Employee(String name, String dept, int salary) {}

List<Employee> employees = List.of(
    new Employee("Alice", "Engineering", 120_000),
    new Employee("Bob",   "Marketing",   80_000),
    new Employee("Carol", "Engineering", 140_000),
    new Employee("Dave",  "Marketing",    75_000)
);

// Средняя зарплата по отделам
Map<String, Double> avgSalaryByDept = employees.stream()
    .collect(Collectors.groupingBy(
        Employee::dept,
        Collectors.averagingInt(Employee::salary)
    ));
// {Engineering=130000.0, Marketing=77500.0}

// Топ-2 зарплаты
List<Integer> top2 = employees.stream()
    .map(Employee::salary)
    .sorted(Comparator.reverseOrder())
    .limit(2)
    .collect(Collectors.toList());
// [140000, 120000]

Что такое Stream API

Stream API (Java 8+) позволяет обрабатывать коллекции и другие источники данных в декларативном стиле, выстраивая цепочку операций. Stream не хранит данные — он описывает преобразования над источником.

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

Возвращают новый Stream; ленивы — не выполняются, пока не вызвана терминальная операция.

• filter(Predicate) — фильтрация элементов.
• map(Function) — преобразование типа.
• flatMap(Function) — раскрытие вложенных стримов.
• sorted() / sorted(Comparator) — сортировка.
• distinct() — уникальные элементы.
• limit(n) / skip(n) — усечение.
• peek(Consumer) — побочный эффект для отладки, не меняет элементы.

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

Запускают пайплайн, потребляют стрим. После вызова стрим нельзя переиспользовать.

• collect(Collectors.toList()) / toSet() / toMap() — сборка.
• forEach(Consumer) — перебор с побочным эффектом.
• reduce(identity, BinaryOperator) — свёртка.
• count(), min(), max() — агрегаты.
• anyMatch() / allMatch() / noneMatch() — предикатные проверки (short-circuit).
• findFirst() / findAny() — поиск первого элемента.
• toArray() — конвертация в массив.

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

long count = employees.parallelStream()
    .filter(e -> e.salary() > 100_000)
    .count();
// Делит работу между ForkJoinPool.commonPool() потоками

Подводные камни

• Нельзя переиспользовать стрим: после терминальной операции стрим закрыт; попытка вызвать операцию повторно бросает IllegalStateException.
• peek() не для бизнес-логики: peek() может не вызваться если терминальная операция не нуждается во всех элементах (например, findFirst()). Используйте только для отладки.
• Порядок промежуточных операций важен: filter().map() эффективнее map().filter() — фильтрация уменьшает набор до дорогого преобразования.
• parallelStream() не всегда быстрее: накладные расходы на разбиение и слияние оправданы только на больших объёмах данных (десятки тысяч элементов) и CPU-bound операциях.
• Изменяемое состояние в лямбдах: лямбды в стримах должны быть non-interfering и stateless. Модификация внешней переменной внутри лямбды — гонка данных в параллельном стриме.
• Infinite streams: Stream.iterate() и Stream.generate() создают бесконечные стримы. Без limit() терминальная операция зависнет.
• Collectors.toList() vs List.copyOf(): toList() (Java 16+) возвращает неизменяемый список; Collectors.toList() — изменяемый. Путаница ведёт к UnsupportedOperationException.

• Путать термин «stream api» с соседним механизмом Java.
• Не называть границу lifecycle, transaction, thread или request для «stream api».
• Игнорировать production-эффекты «stream api»: latency, SQL shape, memory, security или observability.

• Попросить объяснить механизм «stream api» на минимальном примере.
• Проверить, видит ли кандидат failure mode и диагностику для «stream api».
• Уточнить, какие настройки или API меняют «stream api» в реальном сервисе.