Java 8 其中是流中filter（）方法的实现<；T>；接口？ class应用程序{ 公共静态void main（字符串[]args）{ ArrayList myList=新的ArrayList（）； 增加（7）； myList.add（18）； 添加（10）； myList.add（24）； myList.add（17）； 添加（5）； Stream=myList.Stream（）； stream=stream.filter（n->n>10）；//它返回超过10个元素的流 stream.forEach（n->System.out.print（n+）； } }

这段代码过滤调用流，然后打印所有大于10的元素。谓词中的测试方法为我们做到了这一点

但是filter（）方法的实际实现在哪里？它返回的“流”大于10？我不明白

这个问题在某种程度上也适用于forEach（）方法。它如何在流中迭代？因为filter（）和forEach（）方法在接口流中是抽象的，没有实现。

实现

@覆盖
公共最终流过滤器（谓词抽象类ReferencePipeline）具有fileter（）方法的实现

以下是源代码的链接：
@WaseemSwaileh此答案中提供的链接指向lambda/streams的一个旧的原型实现。
ReferencePipeline
不是标准Java SE 8 API的一部分，这就是为什么在javadocs或Eclipse中看不到它的原因。该类仍然存在，但它是一个实现私有类。如果您能够d还张贴了一个如何使用
ReferencePipeline
的示例。否则，答案没有什么价值
class App {
    public static void main(String[] args) {
        ArrayList<Integer> myList = new ArrayList<>();

        myList.add(7);
        myList.add(18);
        myList.add(10);
        myList.add(24);
        myList.add(17);
        myList.add(5);

        Stream<Integer> stream = myList.stream();

        stream = stream.filter(n -> n > 10); // it returns a stream of elements more than 10

        stream.forEach(n -> System.out.print(n + " "));
    }
}

@Override
public final Stream<P_OUT> filter(Predicate<? super P_OUT> predicate) {
    Objects.requireNonNull(predicate);
    return new StatelessOp<P_OUT, P_OUT>(this, StreamShape.REFERENCE,
                                 StreamOpFlag.NOT_SIZED) {
        @Override
        Sink<P_OUT> opWrapSink(int flags, Sink<P_OUT> sink) {
            return new Sink.ChainedReference<P_OUT, P_OUT>(sink) {
                @Override
                public void begin(long size) {
                    downstream.begin(-1);
                }

                @Override
                public void accept(P_OUT u) {
                    if (predicate.test(u))
                        downstream.accept(u);
                }
            };
        }
    };
}