Java stream原理

最新推荐文章于 2022-09-19 14:39:24 发布

dhylanyu1

最新推荐文章于 2022-09-19 14:39:24 发布

阅读量290

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/dhylanyu1/article/details/118879705

版权

Java 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

Java stream原理

常用的stream方法
需要解决的问题
stream包的分类
解决问题
并行执行
- Work Stealing原理：

常用的stream方法


中间操作	无状态	unordered、filter、map、mapToInt、mapToLong、mapToDouble、flatMap、flatMapToInt、flatMapToLong、flatMapToDouble、peek
中间操作	有状态	distinct、sorted、limit、skip
终止操作	非短路操作	forEach、forEachOrdered、toArray、reduce、collect、max、min、count
终止操作	短路操作	anyMatch、allMatch、noneMatch、findFirst、findAny

有无状态指的是元素的处理受不受之前元素的影响。
短路和非短路指的是遇到符合条件的元素就返回。

需要解决的问题

如何记录每次操作
操作如何叠加
叠加后的操作如何执行
最后结果如何存储

stream包的分类

主要是各种操作的工厂类、数据的存储结构以及收集器的工厂类等；
主要用于Stream的惰性求值实现；
Stream的并行计算框架；
存储并行流的中间结果；
终结操作的定义

解决问题

如何记录每次操作

使用stage标记每一次的操作，而stream又需要一个callback，因此完整的操作是由<DataSource、Ops、Callback>三元组表示，具体实现时，使用实例化的ReferencePipeline来表示，如

@Override
@SuppressWarnings("unchecked")
public final <R> Stream<R> map(Function<? super P_OUT, ? extends R> mapper) {
    Objects.requireNonNull(mapper);
    return new StatelessOp<P_OUT, R>(this, StreamShape.REFERENCE,
                                 StreamOpFlag.NOT_SORTED | StreamOpFlag.NOT_DISTINCT) {
        @Override
        Sink<P_OUT> opWrapSink(int flags, Sink<R> sink) {
            return new Sink.ChainedReference<P_OUT, R>(sink) {
                @Override
                public void accept(P_OUT u) {
                    downstream.accept(mapper.apply(u));
                }
            };
        }
    };
}

如何叠加

stage记录了每个操作，但是没有执行的逻辑，因此定义了Sink接口，如下：

interface Sink<T> extends Consumer<T> {
    /**
     * Resets the sink state to receive a fresh data set.  This must be called
     * before sending any data to the sink.  After calling {@link #end()},
     * you may call this method to reset the sink for another calculation.
     * @param size The exact size of the data to be pushed downstream, if
     * known or {@code -1} if unknown or infinite.
     *
     * <p>Prior to this call, the sink must be in the initial state, and after
     * this call it is in the active state.
     */
    default void begin(long size) {}

    /**
     * Indicates that all elements have been pushed.  If the {@code Sink} is
     * stateful, it should send any stored state downstream at this time, and
     * should clear any accumulated state (and associated resources).
     *
     * <p>Prior to this call, the sink must be in the active state, and after
     * this call it is returned to the initial state.
     */
    default void end() {}

    /**
     * Indicates that this {@code Sink} does not wish to receive any more data.
     *
     * @implSpec The default implementation always returns false.
     *
     * @return true if cancellation is requested
     */
    default boolean cancellationRequested() {
        return false;
    }

    /**
     * Accepts an int value.
     *
     * @implSpec The default implementation throws IllegalStateException.
     *
     * @throws IllegalStateException if this sink does not accept int values
     */
    default void accept(int value) {
        throw new IllegalStateException("called wrong accept method");
    }
}

如何执行

调用Sink内的方法组合执行：

@Override
final <P_IN> void copyInto(Sink<P_IN> wrappedSink, Spliterator<P_IN> spliterator) {
    Objects.requireNonNull(wrappedSink);

    if (!StreamOpFlag.SHORT_CIRCUIT.isKnown(getStreamAndOpFlags())) {
        wrappedSink.begin(spliterator.getExactSizeIfKnown());
        spliterator.forEachRemaining(wrappedSink);
        wrappedSink.end();
    }
    else {
        copyIntoWithCancel(wrappedSink, spliterator);
    }
}