Сколько раз можно использовать Stream?

Java Streams: Использование один раз

Ответ: Stream можно использовать ровно ОДИН раз. После терминальной операции Stream закрывается.

Почему Stream одноразовый

Stream — это "трубопровод" данных, а не контейнер. После прохождения данных через трубопровод, он закрывается и переиспользовать его нельзя.

import java.util.stream.Stream;
import java.util.Arrays;

public class StreamReuseExample {
    public static void main(String[] args) {
        // Создаём Stream
        Stream<Integer> stream = Arrays.stream(new Integer[]{1, 2, 3, 4, 5});
        
        // Первое использование: filter и count
        long count = stream
            .filter(n -> n > 2)
            .count();
        System.out.println("Count: " + count); // 3
        
        // Второе использование: ОШИБКА!
        try {
            long count2 = stream
                .filter(n -> n > 3)
                .count();
        } catch (IllegalStateException e) {
            System.out.println("Ошибка: " + e.getMessage());
            // "stream has already been operated upon or closed"
        }
    }
}

Пример проблемы

public class BadStreamUsage {
    public static void main(String[] args) {
        var numbers = Arrays.asList(1, 2, 3, 4, 5);
        
        // Создаём Stream
        var stream = numbers.stream();
        
        // Операция 1: фильтруем (терминальная операция — count)
        long count = stream.filter(n -> n > 2).count();
        System.out.println("Count: " + count); // 3
        
        // Операция 2: пытаемся использовать опять
        // stream.forEach(System.out::println); // IllegalStateException!
    }
}

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

Промежуточные (Intermediate) — возвращают новый Stream

.filter()      // Возвращает Stream
.map()         // Возвращает Stream
.flatMap()     // Возвращает Stream
.distinct()    // Возвращает Stream
.sorted()      // Возвращает Stream
.limit()       // Возвращает Stream
.skip()        // Возвращает Stream

Терминальные (Terminal) — закрывают Stream

.forEach()     // Void
.collect()     // Object
.count()       // Long
.sum()         // Integer/Long
.min()         // Optional
.max()         // Optional
.reduce()      // Optional
.findFirst()   // Optional
.findAny()     // Optional
.anyMatch()    // Boolean
.allMatch()    // Boolean
.noneMatch()   // Boolean

Правильное использование

Способ 1: Разные Stream для разных операций

public class CorrectStreamUsage {
    public static void main(String[] args) {
        var numbers = Arrays.asList(1, 2, 3, 4, 5);
        
        // Stream 1
        long count = numbers.stream()
            .filter(n -> n > 2)
            .count();
        System.out.println("Count: " + count); // 3
        
        // Stream 2 (новый!)
        long sum = numbers.stream()
            .filter(n -> n > 2)
            .mapToLong(Long::valueOf)
            .sum();
        System.out.println("Sum: " + sum); // 12 (3+4+5)
        
        // Stream 3 (новый!)
        numbers.stream()
            .filter(n -> n > 2)
            .forEach(System.out::println); // 3 4 5
    }
}

Способ 2: Collect в промежуточный контейнер

public class CollectToList {
    public static void main(String[] args) {
        var numbers = Arrays.asList(1, 2, 3, 4, 5);
        
        // Собираем результат в List (терминальная операция)
        var filtered = numbers.stream()
            .filter(n -> n > 2)
            .collect(Collectors.toList());
        
        // Теперь работаем с List, не со Stream
        System.out.println("Count: " + filtered.size()); // 3
        System.out.println("Sum: " + 
            filtered.stream().mapToInt(Integer::intValue).sum()); // 12
        System.out.println("Max: " + 
            filtered.stream().max(Integer::compare).orElse(0)); // 5
    }
}

Способ 3: Сохранить Stream в переменную (осторожно!)

public class SaveStream {
    public static void main(String[] args) {
        var numbers = Arrays.asList(1, 2, 3, 4, 5);
        
        // Создаём Stream с intermediate операциями
        var stream = numbers.stream()
            .filter(n -> n > 2)
            .map(n -> n * 2);
        // Stream ещё НЕ выполнен, т.к. нет терминальной операции
        
        // Теперь выполняем
        stream.forEach(System.out::println); // 6 8 10
        
        // Опять использовать stream нельзя!
        // stream.forEach(...); // IllegalStateException
    }
}

Пример: Правильный паттерн

public class StreamPatterns {
    public static void main(String[] args) {
        List<Product> products = Arrays.asList(
            new Product("A", 100),
            new Product("B", 200),
            new Product("C", 150)
        );
        
        // Паттерн 1: Все в одной цепочке
        long expensiveCount = products.stream()
            .filter(p -> p.price > 120)
            .count();
        System.out.println("Expensive: " + expensiveCount);
        
        // Паттерн 2: Collect и переиспользовать
        List<Product> expensive = products.stream()
            .filter(p -> p.price > 120)
            .collect(Collectors.toList());
        
        System.out.println("Count: " + expensive.size());
        System.out.println("Names: " + 
            expensive.stream()
                .map(p -> p.name)
                .collect(Collectors.joining(", ")));
    }
}

class Product {
    String name;
    int price;
    
    Product(String name, int price) {
        this.name = name;
        this.price = price;
    }
}

Частая ошибка: Stream в методе

public class StreamMethodError {
    private Stream<Integer> getFilteredNumbers() {
        return Arrays.asList(1, 2, 3, 4, 5).stream()
            .filter(n -> n > 2); // Возвращаем Stream
    }
    
    public static void main(String[] args) {
        StreamMethodError obj = new StreamMethodError();
        
        // Использование 1
        obj.getFilteredNumbers()
            .forEach(System.out::println); // ✓ Работает
        
        // Использование 2
        obj.getFilteredNumbers()
            .forEach(System.out::println); // ✓ Новый Stream, работает
    }
}

Почему Stream одноразовый

Причины:

1. Ленивое вычисление — Stream вычисляется только при терминальной операции
2. Оптимизация памяти — не нужно хранить промежуточные результаты
3. Простота API — явно видно что операция выполнится ровно один раз
4. Паралелизм — сложнее реализовать повторное использование

На собеседовании

Правильный ответ:

"Stream можно использовать ровно один раз. После терминальной операции (как count(), forEach(), collect()) Stream закрывается и больше не может быть использован.

Это потому что Stream — это трубопровод данных, а не контейнер.

Если нужны несколько операций:

• Либо создаём новый Stream каждый раз
• Либо собираем результат в List через collect() и работаем с ним

Ошибка выбросит IllegalStateException: stream has already been operated upon or closed."

Ключевые выводы

• Stream одноразовый — после терминальной операции он закрывается
• Терминальные операции закрывают Stream (forEach, collect, count и т.д.)
• Промежуточные операции возвращают новый Stream (filter, map, sorted)
• Для нескольких операций — создавай новый Stream или collect в List
• Ленивое вычисление — Stream вычисляется только при терминальной операции
• Это не ошибка, а особенность дизайна для оптимизации