实现一个简化版的Stream框架

Java 的 Stream API 中，延迟执行（Lazy Evaluation）的核心在于中间操作不会立即执行，而是在遇到终端操作时，整个操作链才会执行。

我们可以通过迭代器包装的方式以一个简单的方式实现Stream的延迟执行功能。

下面是一个简化版的 Stream 实现，展示了如何通过延迟执行来处理数据流。

简单实现的延迟执行 Stream 类

import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.Objects;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;

public class SimpleStream<T> {

    private final Iterable<T> source;

    private SimpleStream(Iterable<T> source) {
        this.source = source;
    }

    public static <T> SimpleStream<T> of(Iterable<T> source) {
        Objects.requireNonNull(source);
        return new SimpleStream<>(source);
    }

    public SimpleStream<T> filter(Predicate<? super T> predicate) {
        Objects.requireNonNull(predicate);

        Iterable<T> newSource = () -> new Iterator<>() {
            final Iterator<T> iterator = source.iterator();
            T nextElement;
            boolean hasNextComputed = false;
            boolean hasNextResult = false;

            private void computeNext() {
                while (iterator.hasNext()) {
                    T elem = iterator.next();
                    if (predicate.test(elem)) {
                        nextElement = elem;
                        hasNextResult = true;
                        hasNextComputed = true;
                        return;
                    }
                }
                hasNextResult = false;
                hasNextComputed = true;
            }

            @Override
            public boolean hasNext() {
                if (!hasNextComputed) {
                    computeNext();
                }
                return hasNextResult;
            }

            @Override
            public T next() {
                if (!hasNextComputed) {
                    computeNext();
                }
                if (!hasNextResult) {
                    throw new NoSuchElementException();
                }
                hasNextComputed = false; // Reset
                return nextElement;
            }
        };

        return new SimpleStream<>(newSource);
    }

    public <R> SimpleStream<R> map(Function<? super T, ? extends R> mapper) {
        Objects.requireNonNull(mapper);

        Iterable<R> newSource = () -> new Iterator<R>() {
            final Iterator<T> iterator = source.iterator();

            @Override
            public boolean hasNext() {
                return iterator.hasNext();
            }

            @Override
            public R next() {
                T elem = iterator.next();
                return mapper.apply(elem);
            }
        };

        return new SimpleStream<>(newSource);
    }

    public void forEach(Consumer<? super T> action) {
        Objects.requireNonNull(action);

        for (T t : source) {
            action.accept(t);
        }
    }

    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);

        SimpleStream.of(list)
                .filter(x -> {
                    System.out.println("Filter: " + x);
                    return x % 2 == 0;
                })
                .map(x -> {
                    System.out.println("Map: " + x);
                    return x * x;
                })
                .forEach(x -> System.out.println("Result: " + x));
    }

}

运行结果：

Filter: 1
Filter: 2
Map: 2
Result: 4
Filter: 3
Filter: 4
Map: 4
Result: 16
Filter: 5