Можно ли использовать два терминальных оператора в Stream?

Два терминальных оператора в Stream

Нет, нельзя использовать два терминальных оператора на одном Stream'е. После вызова терминального оператора Stream заканчивается и больше не может использоваться.

Почему это ограничение

// ❌ ОШИБКА: попытка использовать Stream дважды
List<Integer> numbers = List.of(1, 2, 3, 4, 5);

Stream<Integer> stream = numbers.stream()
    .filter(n -> n > 2);

// Первый терминальный оператор
long count = stream.count(); // Stream закончилась

// Второй терминальный оператор
List<Integer> result = stream.collect(Collectors.toList());
// IllegalStateException: stream has already been operated upon or closed

Что такое терминальный оператор

Терминальный оператор — это операция которая:

• Возвращает конкретный результат, не Stream
• Является последней операцией в цепи
• Закрывает Stream и делает её неиспользуемой

Intermediate операции (промежуточные):
├─ filter()
├─ map()
├─ flatMap()
├─ distinct()
├─ sorted()
├─ peek()
├─ limit()
└─ skip()
↓
Terminal операции (терминальные):
├─ collect()     → Collection
├─ count()       → long
├─ findFirst()   → Optional
├─ findAny()     → Optional
├─ anyMatch()    → boolean
├─ allMatch()    → boolean
├─ noneMatch()   → boolean
├─ min()         → Optional
├─ max()         → Optional
├─ reduce()      → Optional/T
├─ forEach()     → void
└─ forEachOrdered() → void

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

Ошибка 1: Два collect()

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

// ❌ Неправильно
Stream<Integer> stream = numbers.stream();
List<Integer> list1 = stream.collect(Collectors.toList()); // Termin 1
Set<Integer> set1 = stream.collect(Collectors.toSet());   // ❌ Ошибка!
// IllegalStateException: stream has already been operated upon or closed

Ошибка 2: count() и forEach()

Stream<Integer> stream = numbers.stream();

long count = stream.count(); // Терминальный оператор → Stream закрыта

stream.forEach(System.out::println); // ❌ Ошибка!
// IllegalStateException: stream has already been operated upon or closed

Ошибка 3: findFirst() и anyMatch()

Stream<String> words = Stream.of("hello", "world", "java");

Optional<String> first = words.findFirst(); // Терминальный
boolean hasA = words.anyMatch(w -> w.contains("a")); // ❌ Ошибка!

Решение 1: Создать новый Stream

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

// ✅ Правильно: создаём ДВА разных Stream'а
long count = numbers.stream()
    .filter(n -> n > 2)
    .count();

List<Integer> filtered = numbers.stream()
    .filter(n -> n > 2)
    .collect(Collectors.toList());

Решение 2: Использовать peek() для побочных эффектов

// ❌ Неправильно: два терминальных оператора
Stream<Integer> stream = numbers.stream()
    .filter(n -> n > 2);

long count = stream.count();
stream.forEach(System.out::println); // ❌ Ошибка

// ✅ Правильно: используем peek() для побочного эффекта
long count = numbers.stream()
    .filter(n -> n > 2)
    .peek(System.out::println)  // Intermediate оператор
    .count();                   // Терминальный оператор

Решение 3: Использовать reduce() для сложных вычислений

// ❌ Неправильно: несколько терминальных операторов
Stream<Integer> stream = numbers.stream();
long sum = stream.reduce(0, Integer::sum);
long product = stream.reduce(1, (a, b) -> a * b); // ❌ Ошибка

// ✅ Правильно: использовать reduce() для комплексного результата
List<Integer> numbers = List.of(1, 2, 3, 4, 5);

int sum = numbers.stream()
    .reduce(0, Integer::sum);

int product = numbers.stream()
    .reduce(1, (a, b) -> a * b);

// Или использовать peek() для логирования
int sumWithLogging = numbers.stream()
    .peek(n -> System.out.println("Processing: " + n))
    .reduce(0, Integer::sum);

Практический пример: IKEA товары

// ❌ НЕПРАВИЛЬНО: два терминальных оператора
public void displayProductStats() {
    List<Product> products = productRepository.findAll();
    
    Stream<Product> expensiveProducts = products.stream()
        .filter(p -> p.getPrice() > 1000);
    
    long count = expensiveProducts.count(); // Терм 1
    double avgPrice = expensiveProducts    // ❌ Ошибка!
        .mapToDouble(Product::getPrice)
        .average()
        .orElse(0);
}

// ✅ ПРАВИЛЬНО: создаём новые Stream'ы
public void displayProductStats() {
    List<Product> products = productRepository.findAll();
    
    // Поток 1: подсчёт
    long count = products.stream()
        .filter(p -> p.getPrice() > 1000)
        .count();
    
    // Поток 2: среднее
    double avgPrice = products.stream()
        .filter(p -> p.getPrice() > 1000)
        .mapToDouble(Product::getPrice)
        .average()
        .orElse(0);
    
    System.out.println("Count: " + count);
    System.out.println("Average: " + avgPrice);
}

// ✅ ОПТИМАЛЬНО: собрать всё в один collect()
public void displayProductStats() {
    List<Product> products = productRepository.findAll();
    
    // Один Stream с одним терминальным оператором
    Map<String, Object> stats = products.stream()
        .filter(p -> p.getPrice() > 1000)
        .collect(Collectors.collectingAndThen(
            Collectors.toList(),
            list -> Map.of(
                "count", list.size(),
                "average", list.stream()
                    .mapToDouble(Product::getPrice)
                    .average()
                    .orElse(0)
            )
        ));
    
    System.out.println("Count: " + stats.get("count"));
    System.out.println("Average: " + stats.get("average"));
}

Решение 4: Использовать специализированные коллекторы

// Когда нужны несколько вычислений одновременно

public class ProductStats {
    public long count;
    public double avgPrice;
    public double maxPrice;
}

// ✅ Правильно: один Stream, один collect()
public ProductStats getStats(List<Product> products) {
    return products.stream()
        .filter(p -> p.getPrice() > 1000)
        .collect(Collectors.collectingAndThen(
            Collectors.toList(),
            list -> {
                ProductStats stats = new ProductStats();
                stats.count = list.size();
                stats.avgPrice = list.stream()
                    .mapToDouble(Product::getPrice)
                    .average()
                    .orElse(0);
                stats.maxPrice = list.stream()
                    .mapToDouble(Product::getPrice)
                    .max()
                    .orElse(0);
                return stats;
            }
        ));
}

Решение 5: Кешировать результаты

// Если нужны несколько результатов из одних данных
public class CachedStreamResults {
    
    private List<Integer> numbers = List.of(1, 2, 3, 4, 5);
    private List<Integer> filtered; // Кеш
    
    // ✅ Правильно: сохраняем промежуточный результат
    public List<Integer> getFiltered() {
        if (filtered == null) {
            filtered = numbers.stream()
                .filter(n -> n > 2)
                .collect(Collectors.toList());
        }
        return filtered;
    }
    
    public long getCount() {
        return getFiltered().stream().count();
    }
    
    public double getAverage() {
        return getFiltered().stream()
            .mapToInt(Integer::intValue)
            .average()
            .orElse(0);
    }
}

Правило для запоминания

Stream = Трубопровод в который можно пропустить воду только один раз!

Intermediate операции = расчистка / фильтрация трубы (вода потом идёт дальше)
┌──────────┐
│ Stream 1 │ → filter → map → sorted → Stream 2
└──────────┘                         └──────────┘

Terminal операции = кран который выпускает воду (трубопровод закончился)
┌──────────┐
│ Stream 1 │ → filter → map → sorted → collect()
└──────────┘                           │
                                   Результат
                                   (трубопровод закончился)

Не можно открыть кран дважды на одной трубе!

Проверка: какие операции терминальные

// ✅ Intermediate (можно продолжить Stream)
.filter(p -> true)
.map(p -> p.getName())
.sorted()
.limit(10)
.peek(System.out::println)
.flatMap(s -> Stream.of(s.split("")))

// ❌ Terminal (Stream закончится)
.collect(Collectors.toList())      // Возвращает List
.count()                            // Возвращает long
.forEach(System.out::println)       // Возвращает void
.findFirst()                        // Возвращает Optional
.reduce(0, Integer::sum)            // Возвращает Integer

Лучшие практики

1. Помни: один Stream = один терминальный оператор

   stream.filter(...).count();           // ✅ OK
   stream.filter(...).collect(...);      // ✅ OK
   // но не оба вместе
   

2. Если нужны несколько результатов

   // ✅ Создай несколько Stream'ов
   long count = data.stream().count();
   long sum = data.stream().map(...).count();
   

3. Используй peek() для логирования

   // ✅ Логирование БЕЗ терминального оператора
   result = data.stream()
       .peek(System.out::println)
       .filter(...)
       .collect(...);
   

4. Кеши промежуточные результаты если нужны многократно

   // ✅ Сохранили отфильтрованные данные
   List<T> filtered = data.stream().filter(...).collect(...);
   // Теперь можем использовать filtered.stream() несколько раз
   

Заключение

Нельзя использовать два терминальных оператора на одном Stream'е потому что терминальный оператор закрывает Stream.

Решения:

1. Создать новый Stream для каждого результата
2. Использовать peek() для побочных эффектов
3. Кешировать промежуточные результаты
4. Использовать комплексные коллекторы для получения нескольких результатов в одном терминальном операторе