Java如何实现一个简化版的Stream框架

import java.util.*;
import java.util.function.Function;
import java.util.function.Predicate;

public class SimpleStream<T> {
    private final List<T> source;  // 原始数据
    private final List<Function<List<T>, List<T>>> operations = new ArrayList<>(); // 用于存储操作链

    public SimpleStream(List<T> source) {
        this.source = source;
    }

    // 中间操作：filter
    public SimpleStream<T> filter(Predicate<T> predicate) {
        operations.add(list -> {
            List<T> result = new ArrayList<>();
            for (T item : list) {
                if (predicate.test(item)) {
                    result.add(item);
                }
            }
            return result;
        });
        return this;
    }

    // 中间操作：map
    public <R> SimpleStream<R> map(Function<T, R> mapper) {
        // 通过 Function 将当前 SimpleStream 转换为新类型的 SimpleStream
        SimpleStream<R> newStream = new SimpleStream<>(null);
        operations.add(list -> {
            List<R> result = new ArrayList<>();
            for (T item : list) {
                result.add(mapper.apply(item));
            }
            return result;
        });
        newStream.operations.addAll(this.operations); // 继承父级操作链
        return newStream;
    }

    // 终端操作：forEach，触发延迟执行
    public void forEach(java.util.function.Consumer<T> consumer) {
        List<T> result = applyOperations(source); // 在终端操作时应用所有中间操作
        for (T item : result) {
            consumer.accept(item);
        }
    }

    // 终端操作：collect
    public List<T> collect() {
        return applyOperations(source); // 在终端操作时应用所有中间操作
    }

    // 应用所有操作
    private List<T> applyOperations(List<T> input) {
        List<T> result = input;
        for (Function<List<T>, List<T>> operation : operations) {
            result = operation.apply(result); // 按顺序应用所有的操作
        }
        return result;
    }

    // 工厂方法：创建 SimpleStream
    public static <T> SimpleStream<T> of(List<T> source) {
        return new SimpleStream<>(source);
    }

    public static void main(String[] args) {
        // 示例使用
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

        SimpleStream.of(numbers)
                .filter(x -> x > 2) // 延迟执行的过滤操作
                .map(x -> x * 2)    // 延迟执行的映射操作
                .forEach(System.out::println); // 终端操作触发执行
    }
}