Java 8 如何在Java8中实现惰性流？

我正在阅读Java8，特别是“StreamsAPI”。我想知道溪流怎么会懒惰

---

我相信streams只是作为一个库添加的，没有对语言进行任何修改来支持懒惰。此外，如果有人告诉我这是通过反射实现的，我会感到震惊。

没有反射或代理。反射和代理带来的性能成本应该避免，除非没有替代方案，而且性能在

Java

中排名第一

使懒惰成为可能的是做事的实用风格。基本上，

流

以源（例如：列表）、中间操作数（例如：过滤器、映射…）和终端操作（例如：计数、求和等）开始。 中间步骤执行得很慢，因为您传递的函数（lambda）被链接到管道中，将在终端步骤执行

ex: filter(Predicate<? super T>)

---

<代码> EX:过滤器（谓词为什么你需要反射来获得懒惰？例如，考虑这个类：

class LazySeq<T> {

    private final List<T> list;
    private Predicate<? super T> predicate;

    public LazySeq(List<T> input) {
        this.list = new ArrayList<>(input);
    }

    //Here you just store the predicate, but you don't perform a filtering
    //You could also return a new LazySeq with a new state
    public LazySeq<T> filter(Predicate<? super T> predicate) {
        this.predicate = predicate;
        return this;
    }

    public void forEach(Consumer<? super T> consumer){
        if(predicate == null) {
            list.forEach(consumer);
        } else {
            for(T elem : list) {
                if(predicate.test(elem)) {
                    consumer.accept(elem);
                }
            }
        }
    }
}

如果在调用filter之后看到序列的内容，您将看到它始终是

1、2、3、4

。但是，当调用终端操作（例如

forEach

）时，将在使用使用者之前完成筛选。例如：

LazySeq<Integer> lazySeq = new LazySeq<>(Arrays.asList(1, 2, 3, 4));
lazySeq = lazySeq.filter(i -> i%2 == 0);

lazySeq.filter(i -> i%2 == 0).forEach(System.out::println);

将打印2和4

这与

流

s的原理相同。从源代码中，可以链接具有特定属性的操作。这些操作要么是中间操作，返回惰性流（例如

过滤器

或

映射

），要么是终端操作（例如

forEach

）。其中一些终端操作是短路操作（例如

findFirst

），因此您可能不会遍历所有管道（例如，您可以考虑在for循环中提前返回，该循环返回数组中某个值的索引）

调用终端操作时，此操作链将开始执行，以便最终获得预期结果

惰性可以通过在应用中间操作时在管道上存储一个新状态来实现，当您调用终端操作时，您可以逐个查看数据上的所有状态

---

流API实际上并不是以这种方式实现的（它有点复杂），但实际上原理就在这里。

流不是数据容器，而是逻辑容器。您只需要传入接口实例来记住逻辑

考虑以下代码：

class FilterIterable<T> implements Iterable<T>
{
    private Iterable<? extends T> iter;
    private Predicate<? super T> pred;

    public FilterIterable(Iterable<? extends T> iter, Predicate<? super T> pred) {
        this.iter = iter;
        this.pred = pred;
    }

    public Iterator<T> iterator() {
        return FilterIterator<T>();
    }

    class FilterIterator<T> implements Iterator<T>
    {
        private Iterator<? extends T> iterator = iter.iterator();
        private T next = null;

        FilterIterator() {
            getNext();
        }

        private void getNext() {
            next = null;
            while (iterator.hasNext()) {
                T temp = iterator.next();
                if (pred.test(temp)) {
                    next = temp;
                    break;
                }
            }
        }

        public boolean hasNext() { return next != null; }

        public T next() {
            T temp = next;
            getNext();
            return temp;
        }       
    }
}

class FilterTable实现了Iterable
{
二等兵IterableI接受了Alexi的回答，因为它让我更好地了解了我在寻找什么。但是，Hustmphrr的回答看起来更精致。谢谢大家。