Можно ли повторно использовать закрытый Stream?

Повторное использование закрытого Stream

Нет, нельзя повторно использовать закрытый Stream. После вызова метода close() на Stream, он перестаёт быть функциональным. Попытка использовать закрытый Stream приведёт к исключению IllegalStateException.

Почему Stream нельзя переиспользовать?

Состояние Stream

Stream имеет внутреннее состояние, которое включает:

• Позицию в исходном источнике данных
• Статус промежуточных операций (filter, map и т.д.)
• Флаг того, был ли Stream закрыт

Когда вы вызываете close(), Stream освобождает все ресурсы и помечает себя как закрытый. Дальнейшие операции невозможны.

Пример ошибки

import java.util.stream.Stream;

public class StreamExample {
    public static void main(String[] args) {
        Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
        
        // Работа со Stream
        stream.filter(x -> x > 2).forEach(System.out::println);
        
        // Закрываем Stream
        stream.close();
        
        // ❌ Попытка повторного использования — ОШИБКА!
        stream.filter(x -> x < 4).forEach(System.out::println);
        // java.lang.IllegalStateException: stream has already been operated upon or closed
    }
}

Исключения при использовании закрытого Stream

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.stream.Stream;

public class FileStreamExample {
    public static void main(String[] args) throws IOException {
        Stream<String> lines = Files.lines(Paths.get("file.txt"));
        
        // Первый проход
        lines.filter(l -> l.contains("error")).forEach(System.out::println);
        lines.close();
        
        // ❌ Второй проход — исключение!
        try {
            lines.map(String::toUpperCase).forEach(System.out::println);
        } catch (IllegalStateException e) {
            System.err.println("Ошибка: " + e.getMessage());
            // Ошибка: stream has already been operated upon or closed
        }
    }
}

Правильный подход: создавать новый Stream

1. Для каждой операции — новый Stream

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

public class MultipleOperationsExample {
    public static void main(String[] args) throws IOException {
        // Первая операция
        try (Stream<String> lines = Files.lines(Paths.get("file.txt"))) {
            lines.filter(l -> l.contains("error"))
                 .forEach(System.out::println);
        } // Stream автоматически закрывается здесь
        
        // Вторая операция — новый Stream
        try (Stream<String> lines = Files.lines(Paths.get("file.txt"))) {
            lines.map(String::toUpperCase)
                 .forEach(System.out::println);
        } // Stream автоматически закрывается здесь
    }
}

2. Выполнить все операции перед закрытием

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

public class CompleteOperationsExample {
    public static void main(String[] args) {
        Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5);
        
        // Выполняем все операции в одной цепочке
        List<Integer> filtered = stream
            .filter(x -> x > 2)
            .collect(Collectors.toList());
        
        // После collect() Stream закрывается
        System.out.println("Результат: " + filtered);
    }
}

3. Использование Try-With-Resources (самый безопасный способ)

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.List;
import java.util.stream.Collectors;

public class TryWithResourcesExample {
    public static void main(String[] args) throws IOException {
        // Способ 1: обработать и собрать результат
        try (var lines = Files.lines(Paths.get("file.txt"))) {
            List<String> errors = lines
                .filter(l -> l.contains("error"))
                .collect(Collectors.toList());
            
            System.out.println("Ошибки: " + errors);
        } // Stream автоматически закрывается благодаря try-with-resources
        
        // Способ 2: нужна вторая обработка — новый try блок
        try (var lines = Files.lines(Paths.get("file.txt"))) {
            long count = lines.count();
            System.out.println("Всего строк: " + count);
        }
    }
}

4. Кэширование результатов вместо Stream

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

public class CachingExample {
    private List<Integer> data;
    
    public CachingExample(int... values) {
        // Сразу преобразуем Stream в List (изменяемый источник данных)
        this.data = Stream.of(values)
            .boxed()
            .collect(Collectors.toList());
    }
    
    public void processMultipleTimes() {
        // Теперь можно работать с data сколько угодно раз
        System.out.println("Фильтр > 2: " + 
            data.stream().filter(x -> x > 2).collect(Collectors.toList()));
        
        System.out.println("Фильтр < 4: " + 
            data.stream().filter(x -> x < 4).collect(Collectors.toList()));
        
        System.out.println("Маппинг * 2: " + 
            data.stream().map(x -> x * 2).collect(Collectors.toList()));
    }
}

Сравнение подходов

Заключение

Stream — это одноразовый инструмент. После вызова close() или завершения терминальной операции (forEach, collect и т.д.), он становится непригодным для использования. Для обработки одних и тех же данных несколько раз используйте Try-With-Resources, создавайте новый Stream каждый раз или кэшируйте данные в List/Collection. Это важный принцип работы со Stream API в Java.