如何缓存Supplier<Stream<T>>的流元素以支持多次遍历？

你提到的提前把流元素收集到集合里的方案，确实会存在“首次遍历浪费”的问题——如果这个流根本没被用到，那提前收集的操作就白做了。所以更合理的思路是懒加载缓存：只有当第一次真正需要遍历流的时候，才去生成并缓存元素，后续所有调用都直接复用缓存好的序列。

核心实现思路 #

• 用一个容器（比如List<T>）存储缓存的元素，初始状态为空
• 包装原有的Supplier<Stream<T>>，重写get()方法做判断：
  • 如果缓存未初始化，就从原数据源获取流，将元素收集到缓存中
  • 之后每次调用get()，都基于缓存的元素生成新的Stream返回
  • 多线程场景下要加线程安全保障，避免缓存重复初始化

通用代码实现 #

下面是兼顾单线程和多线程场景的通用实现：

import java.util.List;
import java.util.concurrent.atomic.AtomicReference;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import java.util.function.Supplier;

public class CachedStreamSupplier<T> implements Supplier<Stream<T>> {
    private final Supplier<Stream<T>> originalSource;
    private final AtomicReference<List<T>> cache = new AtomicReference<>();

    public CachedStreamSupplier(Supplier<Stream<T>> originalSource) {
        this.originalSource = originalSource;
    }

    @Override
    public Stream<T> get() {
        // 双重检查锁，确保缓存只初始化一次
        List<T> cachedElements = cache.get();
        if (cachedElements == null) {
            synchronized (this) {
                cachedElements = cache.get();
                if (cachedElements == null) {
                    // 首次调用时，从原数据源获取流并缓存元素
                    cachedElements = originalSource.get().collect(Collectors.toList());
                    cache.set(cachedElements);
                }
            }
        }
        // 返回缓存元素的新流，保证每次遍历都是独立可重复的
        return cachedElements.stream();
    }
}

示例用法（以3月温度序列为例） #

// 原数据源：每次get()都会生成相同的温度序列流
Supplier<Stream<Integer>> marchTempSrc = () -> Stream.of(12, 15, 18, 14, 16);

// 包装成带缓存的Supplier
Supplier<Stream<Integer>> cachedTempSrc = new CachedStreamSupplier<>(marchTempSrc);

// 第一次遍历：触发缓存初始化，会执行原流的收集操作
cachedTempSrc.get().forEach(temp -> System.out.println("第一次遍历温度：" + temp));

// 第二次遍历：直接复用缓存的元素，不会再调用原marchTempSrc.get()
cachedTempSrc.get().forEach(temp -> System.out.println("第二次遍历温度：" + temp));

方案优势 #

• 懒加载特性：只有当流真正被使用时才会执行收集操作，避免无用的资源消耗
• 可重复遍历：每次get()返回的都是基于缓存元素的新流，支持多次遍历同一序列
• 线程安全：通过AtomicReference加双重检查锁，保证多线程环境下缓存只会被初始化一次
• 低侵入性：完全包装原Supplier，不需要修改原数据源的实现逻辑

如果是单线程场景，还可以简化掉同步块，直接用普通List<T>变量判断是否为空即可，但多线程场景下一定要保留线程安全保障哦。

内容的提问来源于stack exchange，提问作者Miguel Gamboa