Что такое lazy evaluation в Stream?

🟢 Junior Level

Lazy evaluation (ленивые вычисления) — это стратегия, при которой промежуточные (intermediate) операции не выполняются сразу, а только записываются в «план». Реальная работа начинается исключительно при вызове terminal-операции — той, которая запускает конвейер (например, collect, forEach, count).

Ленивость — как обещание: стрим «обещает» выполнить операции, но начнёт только когда вы запросите результат. Без terminal операции стрим — просто описание плана.

// Эти операции НЕ выполняются сразу
Stream<String> stream = list.stream()
    .filter(s -> s.startsWith("A"))  // только записано в план
    .map(String::toUpperCase);        // только записано в план

// Только здесь начинается реальная работа
List<String> result = stream.collect(Collectors.toList());

Разбор примера: если list = ["Apple", "Banana", "Apricot"], то при вызове collect:

Элемент "Apple" проходит filter (начинается с “A” — да) → map → "APPLE" → добавлен в результат
Элемент "Banana" проходит filter (не начинается с “A”) → отбрасывается, map НЕ вызывается
Элемент "Apricot" проходит filter (да) → map → "APRICOT" → добавлен в результат

Зачем это нужно:

Экономия ресурсов — не обрабатываем данные, которые не нужны
Возможность работать с бесконечными стримами

🟡 Middle Level

Внутренний механизм: Pipeline и Sink

Каждая intermediate-операция создает объект AbstractPipeline (внутренний класс JDK, связывающий стадии конвейера в двусвязный список — каждый узел хранит ссылку на предыдущую и следующую операцию). При вызове terminal-операции этот список превращается в цепочку Sink — объектов-обработчиков, каждый из которых принимает элемент, обрабатывает его и передает следующему Sink.

Что такое Spliterator: это итератор с поддержкой параллельного разбиения (split). Он «проталкивает» элементы через цепочку Sink по одному.

Horizontal vs Vertical Execution

Императивный подход (Horizontal):

filter для всех → промежуточный список → map для всех → результат

Stream API (Vertical):

Элемент 1: filter → map → collect
Элемент 2: filter → map → collect
...

Преимущества

Экономия памяти: Не нужны промежуточные коллекции
Short-circuiting (короткое замыкание): .limit(1) остановит обработку после первого элемента — конвейер не будет запрашивать оставшиеся данные. Аналог break в цикле.
Infinite Streams: Можно работать с бесконечными стримами (Stream.generate())

🔴 Senior Level

Когда ленивость стрима — проблема

Нужно выполнить побочный эффект (логирование, метрики) — ленивость может пропустить операции при short-circuit
I/O внутри пайплайна — соединение не откроется до terminal операции, что может удивить
Отладка — стек-трейс начинается от terminal операции, не от места создания стрима

Loop Fusion (Слияние циклов)

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

Опасности ленивости

Скрытые исключения:

Stream<Integer> stream = list.stream()
    .map(n -> 100 / n); // Деление на ноль! Но ошибка не здесь...

stream.collect(toList()); // ...а здесь — при terminal операции

Side Effects Trap: Если peek() что-то пишет в БД, а terminal операцию не вызвали — запись не произойдет.

Debugging

Breakpoint внутри лямбды ленивой операции не сработает до вызова terminal
Если логи из peek() выводятся вперемешку (элемент 1 прошел всё, потом элемент 2) — это визуальное доказательство вертикального выполнения

Диагностика

IntelliJ Stream Debugger позволяет увидеть «карту» прохождения элементов через вертикальный конвейер.

Когда НЕ использовать lazy evaluation

Когда нужна ранняя валидация. Если map содержит операцию, которая может упасть (деление на ноль, парсинг), ошибка проявится только при terminal-операции — далеко от места объявления. Для раннего обнаружения ошибок используйте императивный цикл.
Когда побочные эффекты ожидаемы на каждой стадии. Lazy evaluation делает порядок выполнения неочевидным для разработчика, привычного к пошаговому циклу. Если важно, чтобы каждая операция выполнила своё действие до перехода к следующей — используйте обычный for.
Для отладки в production. Стек-трейс при ошибке внутри ленивой лямбды указывает на terminal-операцию, а не на проблемный map/filter, что затрудняет диагностику.

🎯 Шпаргалка для интервью

Обязательно знать:

Intermediate операции не выполняются до вызова terminal операции — это и есть lazy evaluation
Без terminal операции стрим — просто описание плана обработки данных
Vertical execution: каждый элемент проходит весь конвейер целиком, а не горизонтально
Loop Fusion: JIT может объединить несколько лямбд в один машинный код
Ленивость экономит ресурсы — не обрабатываются ненужные данные
Short-circuit операции (limit) останавливают конвейер досрочно
Исключения в ленивых операциях проявляются только при terminal операции
Side effects через peek() не сработают без terminal операции

Частые уточняющие вопросы:

Почему filter не выполняется сразу? — Intermediate операции только записываются в план (Pipeline), реальная работа начинается от terminal операции (collect, forEach).
Что такое Loop Fusion? — JIT-оптимизация, объединяющая несколько стадий конвейера в один машинный код для эффективного использования кэша процессора.
Можно ли выполнить стрим без terminal операции? — Можно создать, но обработка не начнётся — элементы не будут обработаны.
Почему стек-трейс указывает на terminal операцию? — Потому что именно она запускает конвейер; реальная ошибка находится внутри лямбды intermediate операции.

Красные флаги (НЕ говорить):

«Stream выполняется сразу при создании» — неверно, стрим ленивый
«Промежуточные операции создают промежуточные коллекции» — неверно, vertical execution обходится без них
«Можно выполнить один стрим дважды» — неверно, стримы одноразовые (флаг linkedOrConsumed)
«peek() всегда выполнит побочный эффект» — неверно, только при вызове terminal операции

Связанные темы:

[[22. Когда начинается выполнение операций в Stream]]
[[24. Как работает короткое замыкание (short-circuiting) в Stream]]
[[23. Что делают операции distinct(), sorted(), limit(), skip()]]
[[26. Что делают операции findFirst() и findAny()]]