Java中stream流的filter机制理解

一开始我并不理解，为什么filter接受一个实现了Predicate接口的对象后，就能通过重写的test方法来筛选元素，这个将筛选后的元素放到新的流中，我并不知道如何实现的。
后来我发现ReferencePipeline抽象类中重写了filter方法，并且Collection中的stream方法返回的是StreamSupport.stream方法，而StreamSupport.stream方法返回的是ReferencePipeline.Head（）。所以大致机制应该是创建的stream对象本质是创建的关于ReferencePipeline的对象，所以使用stream的filter方法实际上是调用的ReferencePipeline重写后的方法。在ReferencePipeline类中应该实现了返回新的ReferencePipeline对象，并且将经过中间方法后的元素放到新的对象上面。

arrayList.stream()

default Stream<E> stream() {
        return **StreamSupport.stream**(spliterator(), false);
    }

public static <T> Stream<T> stream(Spliterator<T> spliterator, boolean parallel) {
        Objects.requireNonNull(spliterator);
        **return new ReferencePipeline.Head**<>(spliterator,
                                            StreamOpFlag.fromCharacteristics(spliterator),
                                            parallel);
    }

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);
                    }
                };
            }
        };
    }