Можно ли вызвать терминальную операцию несколько раз на одном потоке?

Можно ли вызвать терминальную операцию несколько раз на одном потоке

Ответ: Нет! Терминальная операция "закрывает" поток, и повторный вызов выбросит исключение. Вот полное объяснение:

1. Быстрый ответ

Попытка вызвать terminal operation дважды

public class StreamTerminalOperationError {
    
    public static void main(String[] args) {
        Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
        
        // Первый вызов terminal operation — OK
        long count = stream.count();  // ✓ Works, возвращает 5
        System.out.println("Count: " + count);
        
        // Второй вызов terminal operation на том же потоке — ОШИБКА!
        long count2 = stream.count();  // ✗ IllegalStateException!
        System.out.println("Count2: " + count2);
    }
}

/*
Результат:
Count: 5
Exception in thread "main" java.lang.IllegalStateException: 
    stream has already been operated upon or closed
*/

2. Что такое Stream в Java

Stream = Lazy Pipeline

public class StreamConcept {
    
    public void explainStreamPipeline() {
        /*
        Stream состоит из 3 частей:
        
        1. SOURCE (Источник)
           Stream.of(1, 2, 3)
        
        2. INTERMEDIATE OPERATIONS (Промежуточные)
           .filter(x -> x > 1)
           .map(x -> x * 2)
           (могут вызваться несколько раз без выполнения)
        
        3. TERMINAL OPERATION (Терминальная)
           .collect(), .forEach(), .count(), .reduce()
           (запускает всю цепь)
           (может быть вызвана только ОДИН раз!)
        */
    }
}

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

public class IntermediateVsTerminal {
    
    public void demonstrate() {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        
        // ПРОМЕЖУТОЧНЫЕ операции (можно вызвать многоразово)
        Stream<Integer> stream = numbers.stream()
            .filter(x -> x > 1)      // Промежуточная
            .map(x -> x * 2);        // Промежуточная
            // На этом этапе НИЧЕГО не выполнилось!
        
        // ТЕРМИНАЛЬНЫЕ операции (только один раз!)
        // stream.forEach(System.out::println);  // ✓ Первый вызов
        // stream.forEach(System.out::println);  // ✗ Ошибка! Поток закрыт
    }
}

3. Примеры терминальных операций

Список всех терминальных операций

public class TerminalOperations {
    
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        
        // 1. forEach() — выполнить действие для каждого элемента
        Stream<Integer> s1 = numbers.stream();
        s1.forEach(System.out::println);
        // s1.forEach(...);  ✗ IllegalStateException!
        
        // 2. count() — подсчитать элементы
        Stream<Integer> s2 = numbers.stream();
        long count = s2.count();  // 5
        // count = s2.count();    ✗ Ошибка!
        
        // 3. reduce() — свертка
        Stream<Integer> s3 = numbers.stream();
        Optional<Integer> sum = s3.reduce(Integer::sum);
        // sum = s3.reduce(...);  ✗ Ошибка!
        
        // 4. collect() — собрать в коллекцию
        Stream<Integer> s4 = numbers.stream();
        List<Integer> list = s4.collect(Collectors.toList());
        // list = s4.collect(...);  ✗ Ошибка!
        
        // 5. findFirst() / findAny() — найти элемент
        Stream<Integer> s5 = numbers.stream();
        Optional<Integer> first = s5.findFirst();
        // first = s5.findFirst();  ✗ Ошибка!
        
        // 6. anyMatch() / allMatch() / noneMatch() — проверить условие
        Stream<Integer> s6 = numbers.stream();
        boolean any = s6.anyMatch(x -> x > 3);
        // any = s6.anyMatch(...);  ✗ Ошибка!
        
        // 7. min() / max() — найти минимум/максимум
        Stream<Integer> s7 = numbers.stream();
        Optional<Integer> max = s7.max(Comparator.naturalOrder());
        // max = s7.max(...);  ✗ Ошибка!
        
        // 8. toArray() — в массив
        Stream<Integer> s8 = numbers.stream();
        Integer[] array = s8.toArray(Integer[]::new);
        // array = s8.toArray(...);  ✗ Ошибка!
    }
}

4. Почему это так устроено

Stream гарантирует single-use

public class WhyStreamIsOneUse {
    
    public void explainReasons() {
        /*
        ПРИЧИНА 1: Состояние потока
        - Stream отслеживает свое состояние (activated, closed)
        - После terminal operation → поток переходит в CLOSED
        - Повторное использование = ошибка
        
        ПРИЧИНА 2: Lazy evaluation
        - Промежуточные операции не выполняются
        - Только terminal operation запускает конвейер
        - После execution → поток исчерпан
        
        ПРИЧИНА 3: Предотвращение ошибок
        - Легко забыть, что поток использован
        - Лучше выбросить исключение, чем молча повторить
        - Это помогает поймать ошибки в разработке
        */
    }
}

5. Как правильно вызвать несколько операций

Решение 1: Разные потоки из одного источника

public class MultipleOperationsCorrect {
    
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        
        // Создаем поток каждый раз заново
        long count = numbers.stream()
            .filter(x -> x > 1)
            .count();  // ✓ OK
        System.out.println("Count: " + count);
        
        // Новый поток!
        long sum = numbers.stream()
            .filter(x -> x > 1)
            .mapToInt(Integer::intValue)
            .sum();  // ✓ OK
        System.out.println("Sum: " + sum);
        
        // Еще один новый поток!
        List<Integer> list = numbers.stream()
            .filter(x -> x > 1)
            .collect(Collectors.toList());  // ✓ OK
        System.out.println("List: " + list);
    }
}

Решение 2: Сделать всё в один вызов terminal operation

public class SingleTerminalOperation {
    
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        
        // Один terminal operation — множество результатов
        Map<String, Object> results = numbers.stream()
            .filter(x -> x > 1)
            .collect(Collectors.collectingAndThen(
                Collectors.toList(),
                list -> {
                    Map<String, Object> map = new HashMap<>();
                    map.put("count", list.size());
                    map.put("sum", list.stream().mapToInt(Integer::intValue).sum());
                    map.put("list", list);
                    return map;
                }
            ));
        
        System.out.println("Count: " + results.get("count"));
        System.out.println("Sum: " + results.get("sum"));
        System.out.println("List: " + results.get("list"));
    }
}

Решение 3: Сохранить результат промежуточной операции

public class SaveIntermediateResult {
    
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        
        // Сохраняем результат в List (это terminal operation!)
        List<Integer> filtered = numbers.stream()
            .filter(x -> x > 1)
            .map(x -> x * 2)
            .collect(Collectors.toList());  // Terminal operation
        
        // Теперь работаем с List, не со Stream
        long count = filtered.size();
        int sum = filtered.stream().mapToInt(Integer::intValue).sum();
        
        System.out.println("Count: " + count);
        System.out.println("Sum: " + sum);
    }
}

6. Примеры ошибок

Ошибка 1: Повторный вызов на том же потоке

public class Error1_RepeatedTerminal {
    
    public void wrong() {
        Stream<Integer> stream = Stream.of(1, 2, 3);
        
        stream.forEach(System.out::println);  // ✓ First call
        stream.forEach(System.out::println);  // ✗ IllegalStateException!
    }
    
    public void correct() {
        Stream.of(1, 2, 3).forEach(System.out::println);  // ✓ OK
        Stream.of(1, 2, 3).forEach(System.out::println);  // ✓ OK (new stream)
    }
}

Ошибка 2: Сохранить Stream и использовать дважды

public class Error2_SavedStream {
    
    public void wrong() {
        Stream<Integer> stream = Stream.of(1, 2, 3)
            .filter(x -> x > 1);
        
        long count = stream.count();  // ✓ First
        List<Integer> list = stream.collect(Collectors.toList());  // ✗ Error!
    }
    
    public void correct() {
        List<Integer> numbers = Arrays.asList(1, 2, 3);
        
        long count = numbers.stream()
            .filter(x -> x > 1)
            .count();  // ✓ OK
        
        List<Integer> list = numbers.stream()
            .filter(x -> x > 1)
            .collect(Collectors.toList());  // ✓ OK (new stream)
    }
}

Ошибка 3: Забыли вызвать terminal operation

public class Error3_NoTerminal {
    
    public void wrong() {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        
        // Это не вызовет ничего! Поток не выполнен
        numbers.stream()
            .filter(x -> x > 1)
            .map(x -> x * 2);  // ✗ Ничего не произойдет!
        
        // Нет terminal operation!
    }
    
    public void correct() {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        
        // ✓ Terminal operation!
        List<Integer> result = numbers.stream()
            .filter(x -> x > 1)
            .map(x -> x * 2)
            .collect(Collectors.toList());  // ← Terminal!
    }
}

7. Таблица: Промежуточные vs Терминальные

8. Best Practices

✓ ХОРОШО: Создавай новый поток для каждой операции

public class GoodPractice1 {
    
    public void multipleAnalyses(List<Integer> data) {
        // Каждый раз новый поток
        long count = data.stream().count();
        int sum = data.stream().mapToInt(Integer::intValue).sum();
        int avg = (int) data.stream().mapToInt(Integer::intValue).average().orElse(0);
        
        System.out.println("Count: " + count + ", Sum: " + sum + ", Avg: " + avg);
    }
}

✓ ХОРОШО: Сохраняй результаты, не поток

public class GoodPractice2 {
    
    public void processData(List<String> data) {
        // Сохраняем результат, не Stream
        List<String> filtered = data.stream()
            .filter(s -> !s.isEmpty())
            .map(String::toUpperCase)
            .collect(Collectors.toList());
        
        // Теперь можем использовать filtered многоразово
        System.out.println("Size: " + filtered.size());
        filtered.forEach(System.out::println);
    }
}

✓ ХОРОШО: Используй collect() для множественных результатов

public class GoodPractice3 {
    
    public void complexAnalysis(List<Person> people) {
        Map<String, Object> analysis = people.stream()
            .filter(p -> p.getAge() > 18)
            .collect(Collectors.collectingAndThen(
                Collectors.toList(),
                adults -> {
                    Map<String, Object> result = new HashMap<>();
                    result.put("count", adults.size());
                    result.put("names", adults.stream().map(Person::getName).collect(Collectors.toList()));
                    result.put("avgAge", adults.stream().mapToInt(Person::getAge).average().orElse(0));
                    return result;
                }
            ));
    }
}

Итоговый ответ

Нет, терминальную операцию НЕЛЬЗЯ вызвать дважды на одном Stream!

Почему:

IllegalStateException: stream has already been operated upon or closed

Правило:

Stream<T> stream = ...

stream.forEach(...);  // ✓ OK (first terminal operation)
stream.forEach(...);  // ✗ Ошибка! Stream closed

Правильный подход:

1. Создавай новый поток для каждой операции

   data.stream().count();
   data.stream().forEach(...);
   

2. Сохраняй результат, не поток

   List<T> result = data.stream().collect(...);
   // Используй result многоразово
   

3. Используй один terminal operation для множественных результатов

   Map<String, Object> results = data.stream()
       .collect(collectingAndThen(...));
   

Помни:

• Промежуточные операции (filter, map) — можно вызывать многоразово
• Терминальные операции (forEach, collect, count) — только один раз
• После terminal operation → Stream закрыт
• Лучше создавать новый Stream, чем пытаться переиспользовать