Сработает ли промежуточная операция при отсутствии терминальной операции в Stream API?

# Промежуточные операции в Stream API без терминальной операции

Краткий ответ

Нет, промежуточные операции НЕ сработают без терминальной операции.

Stream API использует ленивое вычисление (lazy evaluation). Промежуточные операции (intermediate operations) являются сами по себе ленивыми — они не выполняют работу до тех пор, пока не будет вызвана терминальная операция (terminal operation).

Объяснение ленивого вычисления

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

// Пример БЕЗ терминальной операции
Stream<Integer> stream = numbers.stream()
    .filter(n -> {
        System.out.println("Фильтр: " + n);
        return n > 2;
    })
    .map(n -> {
        System.out.println("Мап: " + n);
        return n * 2;
    });

// В этом месте НИЧЕГО не печатается!
// Промежуточные операции просто "запомнили" инструкции

Пример С терминальной операцией

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

List<Integer> result = numbers.stream()
    .filter(n -> {
        System.out.println("Фильтр: " + n);
        return n > 2;
    })
    .map(n -> {
        System.out.println("Мап: " + n);
        return n * 2;
    })
    .collect(Collectors.toList());  // Терминальная операция!

// Вывод:
// Фильтр: 1
// Фильтр: 2
// Фильтр: 3
// Мап: 3
// Фильтр: 4
// Мап: 4
// Фильтр: 5
// Мап: 5

System.out.println(result);  // [6, 8, 10]

Промежуточные vs Терминальные операции

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

Это операции, которые возвращают новый Stream. Они ленивые:

• filter()
• map()
• flatMap()
• distinct()
• sorted()
• peek()
• limit()
• skip()

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

Это операции, которые заканчивают stream и возвращают результат. Они запускают вычисления:

• collect()
• forEach()
• forEachOrdered()
• toArray()
• reduce()
• min(), max()
• count()
• anyMatch(), allMatch(), noneMatch()
• findFirst(), findAny()

Почему ленивое вычисление полезно?

1. Оптимизация производительности

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

int result = numbers.stream()
    .filter(n -> n > 2)
    .map(n -> n * 2)
    .limit(2)  // Ограничиваем результат
    .reduce(0, Integer::sum);

// filter и map выполнятся только для 2 элементов!
// Благодаря limit(2), остальные элементы не обрабатываются

2. Работа с бесконечными потоками

// Можно работать с бесконечным потоком, если использовать limit
Stream.iterate(0, n -> n + 1)  // Бесконечный поток
    .filter(n -> n % 2 == 0)   // Чётные числа
    .limit(5)                  // Берём только первые 5
    .forEach(System.out::println);  // Терминальная операция

// Вывод: 0, 2, 4, 6, 8

3. Избежание ненужной работы

List<String> words = Arrays.asList("apple", "banana", "cherry", "date");

boolean hasLongWord = words.stream()
    .peek(w -> System.out.println("Проверяю: " + w))
    .anyMatch(w -> w.length() > 5);  // Терминальная

// Вывод:
// Проверяю: apple
// Проверяю: banana
// Результат: true
// cherry и date не будут проверены, т.к. уже найдено совпадение!

Частые ошибки

Ошибка 1: Забыли терминальную операцию

// ❌ НЕПРАВИЛЬНО
List<Integer> numbers = Arrays.asList(1, 2, 3);
numbers.stream()
    .map(n -> n * 2)
    .filter(n -> n > 2);
// Ничего не происходит!

// ✅ ПРАВИЛЬНО
List<Integer> result = numbers.stream()
    .map(n -> n * 2)
    .filter(n -> n > 2)
    .collect(Collectors.toList());  // Добавили терминальную операцию

Ошибка 2: Вызов терминальной операции дважды

// ❌ НЕПРАВИЛЬНО
Stream<Integer> stream = numbers.stream()
    .filter(n -> n > 2);
stream.forEach(System.out::println);  // OK
stream.forEach(System.out::println);  // Ошибка! Stream уже использован

// ✅ ПРАВИЛЬНО
numbers.stream()
    .filter(n -> n > 2)
    .forEach(System.out::println);

Заключение

Промежуточные операции в Stream API работают по принципу ленивого вычисления. Они вообще не выполняют никакой код до тех пор, пока не будет вызвана терминальная операция. Это мощный механизм оптимизации, позволяющий эффективно работать с потоками данных и избегать ненужных вычислений.