ForEach в Java является конечным методом, или промежуточным

ForEach в Java Stream API: терминальный метод

В контексте Java Stream API (начиная с Java 8), метод forEach является терминальным (terminal) методом, а не промежуточным (intermediate). Это фундаментальное различие в работе потоков данных.

Ключевые отличия терминальных и промежуточных методов

• Терминальные методы:

    *   Запускают выполнение конвейера операций Stream.
    *   Потребляют элементы потока и производят конечный результат или побочный эффект (side-effect).
    *   **После вызова терминального метода поток считается потребленным и больше не может быть использован.** Попытка повторно использовать поток вызовет исключение `IllegalStateException`.
    *   Примеры: `forEach()`, `collect()`, `count()`, `reduce()`, `anyMatch()`.

• Промежуточные методы:

    *   Возвращают новый модифицированный Stream, позволяя строить цепочки вызовов (конвейер).
    *   Не выполняют немедленных операций над данными, а лишь описывают их.
    *   Ленивы (lazy) – вычисления происходят только при вызове терминальной операции.
    *   Примеры: `filter()`, `map()`, `sorted()`, `distinct()`, `limit()`.

Доказательство на практике: forEach — терминальный метод

Рассмотрим пример, который демонстрирует, что forEach завершает работу потока:

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

public class ForEachTerminalDemo {
    public static void main(String[] args) {
        List<String> words = List.of("Java", "Stream", "API", "forEach");

        Stream<String> stream = words.stream();

        // Промежуточная операция: преобразуем строки в их длину
        Stream<Integer> lengthStream = stream.map(String::length);

        // ТЕРМИНАЛЬНАЯ операция: forEach выполняет действие для каждого элемента
        lengthStream.forEach(len -> System.out.print(len + " "));
        // Вывод: 4 6 3 7

        System.out.println("\n--- Попытка повторного использования потока ---");
        try {
            // Эта строка вызовет исключение, так как поток уже закрыт
            long count = lengthStream.count();
            System.out.println("Count: " + count);
        } catch (IllegalStateException e) {
            System.err.println("Ошибка: " + e.getMessage());
            // Вывод: Ошибка: stream has already been operated upon or closed
        }
    }
}

В этом примере:

1. Мы создаем поток stream, затем промежуточный поток lengthStream.
2. Вызов forEach на lengthStream запускает весь конвейер (операцию map) и выводит результат.
3. Любая последующая попытка использовать lengthStream (даже для вызова другого терминального метода count()) приводит к IllegalStateException. Это прямое доказательство терминальной природы forEach.

Особенности forEach

1. Побочный эффект (Side-effect): Его основная цель — выполнение действия (часто с побочными эффектами, например, вывод в консоль, запись в лог, изменение внешней коллекции) для каждого элемента. Для чистых операций преобразования или агрегации чаще используются collect() или reduce().
2. Порядок в параллельных потоках: В последовательном потоке (stream()) порядок гарантирован. В параллельном (parallelStream()) — нет, если только поток не имеет характеристику ORDERED (например, List по умолчанию имеет порядок, но forEach его не гарантирует в параллельном режиме. Для сохранения порядка в параллельных потоках существует forEachOrdered()).
3. Возвращаемое значение: void. Он ничего не возвращает, только выполняет действие.

Альтернатива: peek() — промежуточный аналог

Если нужно выполнить действие (например, для отладки) внутри конвейера, не завершая его, используется промежуточный метод peek():

List<String> result = words.stream()
        .filter(s -> s.length() > 3)
        .peek(s -> System.out.println("После фильтра: " + s)) // Промежуточный! Поток жив.
        .map(String::toUpperCase)
        .peek(s -> System.out.println("После map: " + s))
        .collect(Collectors.toList()); // Терминальная операция, запускающая весь конвейер

Вывод для ответа на собеседовании: forEach в Java Stream API — это классический терминальный метод. Он запускает обработку конвейера Stream и потребляет его элементы для выполнения побочного действия. После его вызова поток данных закрывается и не может быть использован повторно. Это ключевое отличие от промежуточных методов (таких как map, filter), которые лишь преобразуют один поток в другой и откладывают вычисления.