Как переиспользовать stream

Ответ

Как переиспользовать Stream

Stream в Java — это одноразовый объект. После использования Stream нельзя переиспользовать напрямую. Однако существуют несколько подходов для достижения подобной функциональности.

Проблема: Stream нельзя переиспользовать

import java.util.*;
import java.util.stream.*;

public class StreamReuseProblem {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        
        Stream<Integer> stream = numbers.stream()
            .filter(n -> n % 2 == 0);
        
        // ✓ Первое использование работает
        System.out.println("First use:");
        stream.forEach(System.out::println);
        
        // ✗ ОШИБКА: Stream already used
        // System.out.println("Second use:");
        // stream.forEach(System.out::println); // IllegalStateException!
    }
}

IllegalStateException: stream has already been operated upon or closed

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

import java.util.*;
import java.util.stream.*;

public class CreateNewStream {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        
        // Создаём новый Stream для каждой операции
        System.out.println("Filtered even numbers:");
        numbers.stream()
            .filter(n -> n % 2 == 0)
            .forEach(System.out::println);
        
        System.out.println("\nSquares:");
        numbers.stream()
            .map(n -> n * n)
            .forEach(System.out::println);
        
        System.out.println("\nCount:");
        long count = numbers.stream()
            .filter(n -> n > 2)
            .count();
        System.out.println(count);
    }
}

Это обычно лучший подход — простой и понятный.

Решение 2: Использовать Supplier для переиспользования логики

import java.util.*;
import java.util.function.Supplier;
import java.util.stream.*;

public class StreamSupplier {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        
        // Supplier создаёт новый Stream каждый раз
        Supplier<Stream<Integer>> streamSupplier = () -> numbers.stream()
            .filter(n -> n % 2 == 0);
        
        // Первое использование
        System.out.println("First operation:");
        streamSupplier.get().forEach(System.out::println);
        
        // Второе использование - новый Stream
        System.out.println("\nSecond operation (count):");
        long count = streamSupplier.get().count();
        System.out.println("Count: " + count);
        
        // Третье использование - новый Stream
        System.out.println("\nThird operation (collect):");
        List<Integer> list = streamSupplier.get()
            .collect(Collectors.toList());
        System.out.println("List: " + list);
    }
}

Решение 3: Сохранить результат вместо Stream

import java.util.*;
import java.util.stream.*;

public class SaveResult {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        
        // Сохраняем результат Stream вместо самого Stream
        List<Integer> evenNumbers = numbers.stream()
            .filter(n -> n % 2 == 0)
            .collect(Collectors.toList());
        
        // Теперь можем переиспользовать результат
        System.out.println("First use of result:");
        System.out.println(evenNumbers);
        
        System.out.println("\nSecond use of result:");
        System.out.println("Count: " + evenNumbers.size());
        
        System.out.println("\nThird use of result:");
        evenNumbers.stream()
            .map(n -> n * 2)
            .forEach(System.out::println);
    }
}

Решение 4: Создать пользовательский класс для переиспользования

import java.util.*;
import java.util.stream.*;

public class ReusableStreamWrapper {
    static class StreamHolder<T> {
        private final List<T> data;
        
        public StreamHolder(List<T> data) {
            this.data = new ArrayList<>(data);
        }
        
        // Каждый метод создаёт новый Stream
        public void forEach(Consumer consumer) {
            data.stream().forEach(consumer);
        }
        
        public <R> List<R> map(Function<T, R> mapper) {
            return data.stream()
                .map(mapper)
                .collect(Collectors.toList());
        }
        
        public List<T> filter(Predicate<T> predicate) {
            return data.stream()
                .filter(predicate)
                .collect(Collectors.toList());
        }
        
        public long count(Predicate<T> predicate) {
            return data.stream()
                .filter(predicate)
                .count();
        }
    }
    
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        StreamHolder<Integer> holder = new StreamHolder<>(numbers);
        
        // Переиспользуем без создания новых Stream явно
        System.out.println("Filter operation:");
        holder.filter(n -> n % 2 == 0).forEach(System.out::println);
        
        System.out.println("\nMap operation:");
        holder.map(n -> n * 2).forEach(System.out::println);
        
        System.out.println("\nCount operation:");
        long count = holder.count(n -> n > 2);
        System.out.println("Count: " + count);
    }
}

Решение 5: Использовать Collections для переиспользования

import java.util.*;
import java.util.stream.*;

public class CollectionsReuse {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        
        // Создаём несколько переиспользуемых коллекций
        List<Integer> evenNumbers = numbers.stream()
            .filter(n -> n % 2 == 0)
            .collect(Collectors.toList());
        
        Map<Boolean, List<Integer>> partitioned = numbers.stream()
            .collect(Collectors.partitioningBy(n -> n % 2 == 0));
        
        Map<Integer, Long> grouped = numbers.stream()
            .collect(Collectors.groupingBy(
                n -> n % 2,
                Collectors.counting()
            ));
        
        // Переиспользуем результаты
        System.out.println("Even numbers: " + evenNumbers);
        System.out.println("Partitioned: " + partitioned);
        System.out.println("Grouped: " + grouped);
        
        // Можем применить Stream к результатам
        System.out.println("\nDoubled even numbers:");
        evenNumbers.stream()
            .map(n -> n * 2)
            .forEach(System.out::println);
    }
}

Решение 6: Использовать Iterator для последовательного доступа

import java.util.*;
import java.util.stream.*;

public class IteratorReuse {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        
        // Создаём фильтрованный список
        List<Integer> filtered = numbers.stream()
            .filter(n -> n % 2 == 0)
            .collect(Collectors.toList());
        
        // Iterator можно переиспользовать
        Iterator<Integer> iterator1 = filtered.iterator();
        System.out.println("First iteration:");
        while (iterator1.hasNext()) {
            System.out.println(iterator1.next());
        }
        
        // Создаём новый Iterator
        Iterator<Integer> iterator2 = filtered.iterator();
        System.out.println("\nSecond iteration:");
        while (iterator2.hasNext()) {
            int num = iterator2.next();
            System.out.println(num * 2);
        }
    }
}

Решение 7: Кашировать Stream для производительности

import java.util.*;
import java.util.stream.*;
import java.util.function.Supplier;

public class CachedStream {
    static class LazyStreamCache<T> {
        private final Supplier<Stream<T>> streamSupplier;
        private List<T> cache;
        
        public LazyStreamCache(Supplier<Stream<T>> streamSupplier) {
            this.streamSupplier = streamSupplier;
        }
        
        // Ленивое кеширование
        private List<T> getCache() {
            if (cache == null) {
                cache = streamSupplier.get()
                    .collect(Collectors.toList());
            }
            return cache;
        }
        
        public void forEach(Consumer<T> consumer) {
            getCache().forEach(consumer);
        }
        
        public <R> List<R> map(Function<T, R> mapper) {
            return getCache().stream()
                .map(mapper)
                .collect(Collectors.toList());
        }
        
        public long count() {
            return getCache().size();
        }
    }
    
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        
        // Создаём кешированный Stream
        LazyStreamCache<Integer> cache = new LazyStreamCache<>(() =>
            numbers.stream()
                .filter(n -> n % 2 == 0)
                .peek(n -> System.out.println("Processing: " + n))
        );
        
        System.out.println("First operation (forEach):");
        cache.forEach(System.out::println);
        
        System.out.println("\nSecond operation (count) - использует кэш:");
        System.out.println("Count: " + cache.count());
        
        System.out.println("\nThird operation (map) - использует кэш:");
        cache.map(n -> n * 2).forEach(System.out::println);
    }
}

Решение 8: Использовать Vavr (функциональная библиотека)

// Добавить зависимость: io.vavr:vavr:0.10.4
import io.vavr.collection.List;
import io.vavr.collection.Stream;

public class VavrStreamReuse {
    public static void main(String[] args) {
        // Vavr Stream поддерживает переиспользование
        Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5)
            .filter(n -> n % 2 == 0);
        
        // Первое использование
        System.out.println("First use:");
        stream.forEach(System.out::println);
        
        // Второе использование - Stream переиспользуется
        System.out.println("\nSecond use:");
        System.out.println("Count: " + stream.length());
        
        // Третье использование
        System.out.println("\nThird use (mapped):");
        stream.map(n -> n * 2).forEach(System.out::println);
    }
}

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

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

1. Создавайте новый Stream при необходимости — это стандартный подход
2. Используйте Supplier для переиспользуемой логики — элегантно и ленивое
3. Сохраняйте результат Stream вместо самого Stream — обычно лучший выбор
4. Избегайте повторных Stream операций — используйте промежуточные результаты
5. Для частого переиспользования кешируйте результаты
6. Используйте Vavr для более функционального подхода

Практический пример

import java.util.*;
import java.util.stream.*;

public class PracticalStreamReuse {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
        
        // Вариант 1: Сохраняем результат (рекомендуется)
        List<String> longNames = names.stream()
            .filter(name -> name.length() > 3)
            .collect(Collectors.toList());
        
        System.out.println("Long names: " + longNames);
        System.out.println("Count: " + longNames.size());
        System.out.println("Uppercase: " + longNames.stream()
            .map(String::toUpperCase)
            .collect(Collectors.toList()));
        
        // Вариант 2: Используем Supplier для логики
        java.util.function.Supplier<Stream<String>> supplier = () -> names.stream()
            .filter(name -> name.length() > 3);
        
        System.out.println("\nUsing Supplier:");
        supplier.get().forEach(System.out::println);
        System.out.println("Count: " + supplier.get().count());
    }
}

Запомните: Stream одноразовый, но результаты Stream переиспользуются!