Когда начинается выполнение операций в Stream

Выполнение операций в Stream начинается строго в момент вызова терминальной (terminal) операции (collect(), toList(), forEach(), count(), findFirst(), reduce()).

🟢 Junior Level

Краткий ответ для собеседования (30 секунд)

Выполнение операций в Stream начинается строго в момент вызова терминальной (terminal) операции (collect(), toList(), forEach(), count(), findFirst(), reduce()).

До тех пор, пока терминальная операция не вызвана, промежуточные операции (filter(), map(), peek(), sorted()) лишь конструируют описание конвейера обработки (дерево этапов). Сами данные не считываются из источника, не фильтруются и не трансформируются. Если терминальная операция вообще не будет вызвана, код внутри промежуточных лямбд никогда не выполнится.

Базовый пример на Java 21

import java.util.List;
import java.util.stream.Stream;

public class ExecutionStartDemo {

    public static void main(String[] args) {
        List<String> items = List.of("стол", "стул", "шкаф");

        // 1. Промежуточные операции: код внутри лямбды сейчас НЕ выполняется!
        Stream<String> stream = items.stream()
            .filter(item -> {
                System.out.println("[Filter] Проверка элемента: " + item);
                return item.startsWith("с");
            })
            .map(String::toUpperCase);

        System.out.println("Конвейер сконфигурирован, терминальная операция НЕ вызывалась.");

        // 2. Вызов терминальной операции — ИМЕННО СЕЙЧАС начинается реальная обработка:
        System.out.println("Вызываем терминальную операцию toList()...");
        List<String> result = stream.toList();

        System.out.println("Результат: " + result);
    }
}

Вывод программы:

Конвейер сконфигурирован, терминальная операция НЕ вызывалась.
Вызываем терминальную операцию toList()...
[Filter] Проверка элемента: стол
[Filter] Проверка элемента: стул
[Filter] Проверка элемента: шкаф
Результат: [СТОЛ, СТУЛ]

🟡 Middle Level

Классификация: Intermediate vs Terminal

Тип операции	Примеры методов	Что возвращает	Запускает обработку?
Intermediate (Ленивые)	`filter`, `map`, `flatMap`, `distinct`, `sorted`, `peek`, `limit`, `skip`	`Stream<T>` / `IntStream`	❌ Нет (лишь добавляет узел в пайплайн)
Terminal (Инициирующие)	`collect`, `toList`, `forEach`, `reduce`, `count`, `findFirst`, `anyMatch`	Значение (`List`, `Optional`, `long`, `void`)	✅ Да (триггер всего вычисления)

Механика запуска: Сборка цепочки `Sink` под капотом

Когда вызывается терминальная операция (например, collect(Collectors.toList())), в недрах AbstractPipeline происходит следующее:

Проверка одноразовости: Проверяется флаг linkedOrConsumed. Если он уже true, выбрасывается IllegalStateException. Затем флаг выставляется в true.
Сборка цепочки Sink в обратном порядке: Начиная с терминального потребителя, рантайм вызывает метод opWrapSink() назад по цепочке узлов к началу стрима, формируя вложенную матрешку из объектов Sink:
```
[Source Spliterator]
        │
        ▼
Sink(filter) ──► проверяет предикат; если true ──►
        │
        ▼
Sink(map) ──► преобразует элемент ──►
        │
        ▼
Sink(terminal collect) ──► добавляет в итоговый ArrayList
```
Запуск протягивания: sourceSpliterator.forEachRemaining(firstSink) начинает последовательно выталкивать элементы источника в первый Sink.

🔴 Senior Level

Байт-код и инлайнинг: `invokedynamic` и `LambdaMetafactory`

При компиляции вызова промежуточной операции:

Лямбда-выражение компилируется в байт-код инструкцию invokedynamic (CallSite).
При первом проходе JVM через LambdaMetafactory генерирует легковесный анонимный внутренний класс, реализующий целевой функциональный интерфейс (например, Predicate).
Тело самой лямбды компилируется в синтетический статический метод текущего класса (lambda$main$0).
Сам вызов сгенерированного метода происходит только тогда, когда метод accept() соответствующего Sink вызывается сплитератором.

Анатомия стек-трейсов исключений (Stream Exception Call Stack)

Если ошибка (например, NullPointerException или деление на ноль) происходит глубоко внутри промежуточного map(), в стек-трейсе точка вызова всегда указывает на терминальную операцию:

Exception in thread "main" java.lang.NullPointerException
    at com.example.Demo.lambda$main$0(Demo.java:18)           <-- Ошибка в лямбде внутри map()
    at java.base/java.util.stream.ReferencePipeline$3$1.accept(...)
    at java.base/java.util.Spliterators$ArraySpliterator.forEachRemaining(...)
    at java.base/java.util.stream.AbstractPipeline.copyInto(...)
    at java.base/java.util.stream.AbstractPipeline.wrapAndCopyInto(...)
    at java.base/java.util.stream.ReduceOps$ReduceOp.evaluateSequential(...)
    at java.base/java.util.stream.AbstractPipeline.evaluate(...)
    at java.base/java.util.stream.ReferencePipeline.collect(...) <-- ТОЧКА СТАРТА ВЫЧИСЛЕНИЯ
    at com.example.Demo.main(Demo.java:24)

Именно вызов терминальной операции раскручивает цикл forEachRemaining() и вызовы Sink.accept().

JIT C2-Оптимизация: Схлопывание в один плоский цикл

Хотя архитектура Stream API с вложенными Sink выглядит тяжеловесной (множество полиморфных вызовов интерфейсов):

После прогрева (Tiered Compilation / C2 JIT) HotSpot компилятор полностью инлайнит (inlines) цепочку вызовов Sink.accept().
Благодаря Escape Analysis промежуточные объекты Sink и замыкания устраняются через скалярное замещение (Scalar Replacement).
В машинном коде конвейер стрима превращается в один плоский ассемблерный цикл по массиву, практически не уступающий по скорости ручному циклу for.

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

30-секундный ответ

«Выполнение операций в стриме начинается исключительно в момент вызова терминальной операции (collect, toList, forEach, count). Промежуточные операции ленивы и лишь строят обратную цепочку обработчиков Sink. При вызове терминальной операции метод AbstractPipeline.evaluate() собирает цепочку Sink, проверяет флаг одноразовости и передает головной Sink в Spliterator.forEachRemaining(). После этого элементы по одному протягиваются сквозь весь конвейер (Loop Fusion). При прогреве JIT-компилятор инлайнит цепочку вызовов Sink в единый плоский цикл.»

Жизненный цикл стрима по шагам

1. collection.stream()    ──► Создается ReferencePipeline.Head с исходным Spliterator
2. .filter(...)           ──► Добавляется узел StatelessOp (работа НЕ началась)
3. .map(...)              ──► Добавляется узел StatelessOp (работа НЕ началась)
4. .toList()              ──► ВЫЗОВ ТЕРМИНАЛЬНОЙ ОПЕРАЦИИ:
                              a) Проверка linkedOrConsumed == false
                              b) Сборка цепочки Sink от конца к началу
                              c) Запуск Spliterator.forEachRemaining(firstSink)
                              d) Завершение, закрытие конвейера, возврат результата

Топ-4 каверзных вопроса на интервью

1. Как `AbstractPipeline` собирает цепочку `Sink` в обратном направлении?

Терминальная операция предоставляет начальный Sink (накопитель результата). Метод wrapSink() проходит по связанному списку узлов стрима от хвоста к голове: каждый узел оборачивает переданный ему downstream-Sink в свой собственный Sink (например, filter оборачивает collect, а map оборачивает filter). В итоге получается цепочка, где первый вызов accept() соответствует первой промежуточной операции.

2. Что произойдет, если в стриме объявлены `filter` и `map` с выводом в консоль, но терминальная операция не вызвана?

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

3. Почему в стек-трейсе ошибка из `map()` падает в строке вызова `collect()`?

Лямбда внутри map() выполняется не в момент вызова метода .map(), а в момент прохода элементов через конвейер, который инициируется методом collect(). Терминальный метод запускает итератор источника данных, поэтому он находится в корне стек-трейса выполнения.

4. Может ли терминальная операция вообще не запускать обход элементов?

Да, в случае шорт-циркуита на пустом источнике или при оптимизациях рантайма Java 9+: вызов .count() на стриме из коллекции SIZED без фильтрации берет размер из сплитератора size() напрямую, не читая ни одного элемента.

Типичные ошибки и Red Flags

🚩 Забывание вызвать терминальную операцию (написание stream.filter(...).map(...) без завершения).
🚩 Предположение, что .stream() запускает фоновый поток обработки.
🚩 Попытка вызвать терминальную операцию дважды на одном объекте стрима.
🚩 Ожидание, что промежуточные операции выполняются строго «по слоям» для всех элементов сразу.