🟢 Junior Level

Stream API — это способ описания последовательности вычислений над данными без их фактического хранения.

В отличие от коллекции (которая хранит элементы в памяти), стрим — это лениво вычисляемый конвейер операций. Вы описываете ЧТО сделать (filter, map, collect), а Stream решает КАК это выполнить.

Основные преимущества:

• Читаемость: Код становится декларативным — вы описываете “что” нужно сделать, а не “как”
• Меньше ошибок: Снижается вероятность ошибок цикла (off-by-one, неправильные индексы)
• Цепочки операций: Можно выстраивать сложные преобразования в одну цепочку

// Старый подход
List<String> result = new ArrayList<>();
for (String s : list) {
    if (s.startsWith("A")) {
        result.add(s.toUpperCase());
    }
}

// Stream API
List<String> result = list.stream()
    .filter(s -> s.startsWith("A"))
    .map(String::toUpperCase)
    .collect(Collectors.toList());

Когда НЕ использовать Stream API

1. Простые операции над маленькими коллекциями (< 100 элементов) — обычный for/for-each проще и быстрее
2. Критичный по latency код — overhead на pipeline ~микросекунды, но в hot path это заметно
3. Работа с примитивами без boxed — используйте IntStream/LongStream, а не Stream

🟡 Middle Level

Как работает Stream API внутри

Stream не хранит данные — он описывает вычисления над данными. Ключевой компонент — Spliterator (Splitable Iterator):

• Умеет разделять данные на части для параллельной обработки
• Сообщает характеристики источника: ORDERED, DISTINCT, SORTED, SIZED

Характеристики Spliterator:

• ORDERED — элементы имеют определённый порядок
• DISTINCT — все элементы уникальны
• SORTED — элементы отсортированы
• SIZED — известен точный размер (ArrayList, массив). Критично для параллелизма!

Типы операций

Intermediate (промежуточные) — ленивые:

• filter, map, flatMap, peek — stateless (без состояния)
• sorted, distinct, limit, skip — stateful (требуют буфера)

Terminal (терминальные) — запускают выполнение:

• collect, reduce, forEach, count, findFirst, anyMatch

Ленивая обработка (Lazy Evaluation)

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

🔴 Senior Level

Internal vs External Iteration

External Iteration (for-each, Iterator):

• Вы контролируете “как” делать итерацию
• JIT-компилятор ограничен в оптимизациях

Internal Iteration (Stream API):

• JIT может применить Loop Unrolling и Vectorization (SIMD)
• Stream API сам решает оптимальный порядок выполнения

Производительность и Highload

Primitive Streams:

// ПЛОХО — создает миллионы объектов Integer
list.stream().map(String::length).reduce(0, Integer::sum)

// ХОРОШО — работает с примитивами
list.stream().mapToInt(String::length).sum()

Fusion (слияние): Современные реализации объединяют несколько промежуточных операций в один проход.

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

• Простые циклы на маленьких коллекциях (до ~1000 элементов) — for-i быстрее, т.к. нет overhead на создание pipeline и Spliterator. На больших данных разница сглаживается.
• Сложные побочные эффекты (код станет нечитаемым)
• I/O операции (блокируют ForkJoinPool)

Параллелизм — подводные камни

.parallel() использует общий ForkJoinPool.commonPool() — бесконтрольное использование может замедлить всё приложение. Эмпирическое правило: параллелизм выгоден при N * Q > 10,000.

Диагностика

• Используйте peek() только для отладки
• IntelliJ Stream Debugger визуализирует прохождение данных
• JMH для бенчмарков параллельных стримов

---

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

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

• Stream API — декларативный способ описания вычислений над данными, не хранит данные в памяти
• Основные преимущества: читаемость, меньше ошибок цикла, удобные цепочки операций
• Intermediate операции ленивые, terminal — запускают выполнение
• Spliterator — ключевой компонент для разделения данных и параллелизма
• Primitive Streams (IntStream, LongStream) эффективнее boxed-версий
• .parallel() использует общий ForkJoinPool.commonPool()
• Не использовать на маленьких коллекциях и в I/O-операциях

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

• Когда Stream API хуже for-each? — На коллекциях < 100 элементов, в hot path с критичной latency, при простых операциях
• Что такое Fusion? — JVM объединяет несколько intermediate операций в один проход
• Почему parallelStream опасен? — Общий ForkJoinPool, блокировка потоков убивает производительность всего приложения
• Как диагностировать проблемы? — JMH для бенчмарков, IntelliJ Stream Debugger, peek() для отладки

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

• «Stream API всегда быстрее for-each» — нет, оверхед на pipeline заметен на малых данных
• «ParallelStream ускорит любую задачу» — только CPU-bound с N*Q > 10,000
• «Stream хранит данные» — нет, это конвейер вычислений, данные — в источнике
• «Можно переиспользовать стрим» — нет, IllegalStateException при повторном использовании

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

• [[2. В чём разница между intermediate и terminal операциями]]
• [[5. Что делает операция collect()]]
• [[9. Что такое параллельные стримы]]
• [[10. Когда использовать parallel streams]]
• [[4. Что делает операция map()]]