Stream流与Lambda表达式（六） SpliteratorDetail

package com.java.design.java8.Stream.StreamDetail.BaseStreamDetail;


import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;


import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.IntConsumer;

/**
 * @author 陈杨
 */
@SpringBootTest
@RunWith(SpringRunner.class)
public class SpliteratorDetail {

    private IntConsumer intConsumer;
    private Consumer consumer;
    private List<String> list;

    @Before
    public void init() {

        intConsumer = System.out::println;
        consumer = System.out::println;
        list = Arrays.asList("Kirito", "Asuna", "Sinon", "Yuuki", "Alice");
    }

    private void action(IntConsumer intConsumer) {
        intConsumer.accept(100);
    }

    @Test
    public void testSpliteratorDetail() {

一、流的创建--源（集合）

// 一、流的创建--源（集合）
/*
Collection集合默认方法 list.stream()

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

@Override
default
Spliterator<E> spliterator () {
    return Spliterators.spliterator(this, 0);
}

public static <T> Spliterator<T> spliterator(Collection<? extends T> c,
int characteristics) {
    return new IteratorSpliterator<>(Objects.requireNonNull(c),
            characteristics);
}*/

//  Collector   接口 与 Collectors   静态类实现
//  Spliterator 接口 与 Spliterators 静态类实现

二、Spliterator 接口

//  二、Spliterator 接口

//  Spliterator 接口
//  对数据源中元素进行遍历或分区
//  An object for traversing and partitioning elements of a source.

//  延迟绑定数据源
//      绑定时机：首次遍历、切分、查询大小 而不是在创建时
//  A  <em>late-binding</em> Spliterator binds to the source of elements at the
//  point of first traversal, first split, or first query for estimated size,
//  rather than at the time the Spliterator is created.

//  非延迟绑定数据源
//      绑定时机：Spliterator创建时 或Spliterator的方法首次调用
//  A Spliterator that is not <em>late-binding</em> binds to the source of elements
//  at the point of construction or first invocation of any method.

//  Spliterator 与 Iterator 的区别:
//
//  Spliterator 优势：通过分解和单元素迭代 支持串行与并行
//                    比Iterator迭代通过hasNext与next性能更好
//  Spliterators, like {@code Iterator}s, are for traversing the elements of  a source.
//  The Spliterator API was designed to support efficient parallel traversal
//  in addition to sequential traversal, by supporting decomposition as well as single-element iteration.
//  In addition, the protocol for accessing elements via a Spliterator is designed to impose
//  smaller per-element overhead than {@code Iterator}, and to avoid the inherent
//  race involved in having separate methods for {@code hasNext()} and {@code next()}.

三、Spliterator特性值

/* public interface Spliterator<T> {

// 三、Spliterator特性值

     * Characteristic value signifying that an encounter order is defined for
     * elements. If so, this Spliterator guarantees that method
     * {@link #trySplit} splits a strict prefix of elements, that method  分割前后对元素加严格前缀
     * {@link #tryAdvance} steps by one element in prefix order, and that 按照元素的顺序前缀遍历
     * {@link #forEachRemaining} performs actions in encounter order.     对剩余元素按照相遇顺序执行action
     *
     * <p>A {@link Collection} has an encounter order if the corresponding
     * {@link Collection#iterator} documents an order. If so, the encounter
     * order is the same as the documented order. Otherwise, a collection does
     * not have an encounter order.
     * 集合是有序的，则文档是有序的
     * 集合是无序的，则文档是无序的
     *
     * @apiNote Encounter order is guaranteed to be ascending index order for
     * any {@link List}. But no order is guaranteed for hash-based collections
     * such as {@link HashSet}. Clients of a Spliterator that reports
     * {@code ORDERED} are expected to preserve ordering constraints in
     * non-commutative parallel computations.
     * 基于索引升序的List     排序-->有序
     * 基于Hash散列的HashSet 排序-->无序
     * 非并发情况下期望要保留 有序集合中 元素的顺序 以返还给客户端调用者

    public static final int ORDERED    = 0x00000010;


     * Characteristic value signifying that, for each pair of
     * encountered elements {@code x, y}, {@code !x.equals(y)}. This
     * applies for example, to a Spliterator based on a {@link Set}.

    基于Set的去重DISTINCT
    public static final int DISTINCT   = 0x00000001;


     * Characteristic value signifying that encounter order follows a defined
     * sort order. If so, method {@link #getComparator()} returns the associated
     * Comparator, or {@code null} if all elements are {@link Comparable} and
     * are sorted by their natural ordering.
     *
     * <p>A Spliterator that reports {@code SORTED} must also report
     * {@code ORDERED}.
     * 已排序的一定是有序的
     *
     * @apiNote The spliterators for {@code Collection} classes in the JDK that
     * implement {@link NavigableSet} or {@link SortedSet} report {@code SORTED}.
     * 如果基于集合的spliterator实现了NavigableSet或SortedSet接口 则为SORTED

    public static final int SORTED     = 0x00000004;


     * Characteristic value signifying that the value returned from
     * {@code estimateSize()} prior to traversal or splitting represents a
     * finite size that, in the absence of structural source modification,
     * represents an exact count of the number of elements that would be
     * encountered by a complete traversal.
     * 源中元素个数有限 源元素结构特性未被修改 estimateSize能在完整遍历过程中 精准计算

    public static final int SIZED      = 0x00000040;


     * Characteristic value signifying that the source guarantees that
     * encountered elements will not be {@code null}. (This applies,
     * for example, to most concurrent collections, queues, and maps.)
     *
    源中元素都不为null
    public static final int NONNULL    = 0x00000100;


     * Characteristic value signifying that the element source cannot be
     * structurally modified; that is, elements cannot be added, replaced, or
     * removed, so such changes cannot occur during traversal. A Spliterator
     * that does not report {@code IMMUTABLE} or {@code CONCURRENT} is expected
     * to have a documented policy (for example throwing
     * {@link ConcurrentModificationException}) concerning structural
     * interference detected during traversal.
     * 源中元素结构不可变
     * 源中元素在遍历过程中 不能被 添加 替换（包含修改） 删除
     * 如果遍历时 发送元素结构发生改变 则不能表示为IMMUTABLE或CONCURRENT 抛出ConcurrentModificationException

    public static final int IMMUTABLE  = 0x00000400;


     * Characteristic value signifying that the element source may be safely
     * concurrently modified (allowing additions, replacements, and/or removals)
     * by multiple threads without external synchronization. If so, the
     * Spliterator is expected to have a documented policy concerning the impact
     * of modifications during traversal.
     *
     * <p>A top-level Spliterator should not report both {@code CONCURRENT} and
     * {@code SIZED}, since the finite size, if known, may change if the source
     * is concurrently modified during traversal. Such a Spliterator is
     * inconsistent and no guarantees can be made about any computation using
     * that Spliterator. Sub-spliterators may report {@code SIZED} if the
     * sub-split size is known and additions or removals to the source are not
     * reflected when traversing.
     *
     * <p>A top-level Spliterator should not report both {@code CONCURRENT} and
     * {@code IMMUTABLE}, since they are mutually exclusive. Such a Spliterator
     * is inconsistent and no guarantees can be made about any computation using
     * that Spliterator. Sub-spliterators may report {@code IMMUTABLE} if
     * additions or removals to the source are not reflected when traversing.
     *
     * @apiNote Most concurrent collections maintain a consistency policy
     * guaranteeing accuracy with respect to elements present at the point of
     * Spliterator construction, but possibly not reflecting subsequent
     * additions or removals.
     * 顶层的Spliterator不能同时拥有CONCURRENT和SIZED特性
     *       并发时可能存在对源进行添加、替换（修改）、删除 以改变元素个数
     * 顶层的Spliterator不能同时拥有CONCURRENT和IMMUTABLE特性
     *       这两种特性是互斥的
     * 大多数并发集合都保持一致性策略，以确保在拆分器构造点存在的元素的准确性，但可能不反映随后的添加或删除

    public static final int CONCURRENT = 0x00001000;


     * Characteristic value signifying that all Spliterators resulting from
     * {@code trySplit()} will be both {@link #SIZED} and {@link #SUBSIZED}.
     * (This means that all child Spliterators, whether direct or indirect, will
     * be {@code SIZED}.)
     *
     * <p>A Spliterator that does not report {@code SIZED} as required by
     * {@code SUBSIZED} is inconsistent and no guarantees can be made about any
     * computation using that Spliterator.
     *
     * @apiNote Some spliterators, such as the top-level spliterator for an
     * approximately balanced binary tree, will report {@code SIZED} but not
     * {@code SUBSIZED}, since it is common to know the size of the entire tree
     * but not the exact sizes of subtrees.
     * 顶层二叉树是SIZED 但不是SUBSIZED 因为不知道子树的大小
     *
    从trySplit返回的子Spliterator都是SIZED 和 SUBSIZED
    public static final int SUBSIZED = 0x00004000;

四、Spliterator方法

//  四、Spliterator方法

     * If a remaining element exists, performs the given action on it，
     * returning {@code true}; else returns {@code false}.  If this
     * Spliterator is {@link #ORDERED} the action is performed on the
     * next element in encounter order.  Exceptions thrown by the
     * action are relayed to the caller.
     *
    尝试遍历：
        如果有下一个元素 就对其执行action
        如果是有序的 按照元素相遇顺序 对其执行action
        如果有异常 将异常信息返回给方法调用者
        tryAdvance() 完成了 Iterator的hasNext()与next()

    boolean tryAdvance(Consumer<? super T> action);


     * Performs the given action for each remaining element, sequentially in
     * the current thread, until all elements have been processed or the action
     * throws an exception.  If this Spliterator is {@link #ORDERED}, actions
     * are performed in encounter order.  Exceptions thrown by the action
     * are relayed to the caller.

    按顺序遍历剩余元素 并对每个元素执行action 直到遍历结束 将异常信息返回给方法调用者
    default void forEachRemaining(Consumer<? super T> action) {
        do { } while (tryAdvance(action));
    }


     * If this spliterator can be partitioned, returns a Spliterator
     * covering elements, that will, upon return from this method, not
     * be covered by this Spliterator.
     *
     * <p>If this Spliterator is {@link #ORDERED}, the returned Spliterator
     * must cover a strict prefix of the elements.
     *
     * <p>Unless this Spliterator covers an infinite number of elements,
     * repeated calls to {@code trySplit()} must eventually return {@code null}.
     * Upon non-null return:
     * <ul>
     * <li>the value reported for {@code estimateSize()} before splitting,
     * must, after splitting, be greater than or equal to {@code estimateSize()}
     * for this and the returned Spliterator; and</li>
     * <li>if this Spliterator is {@code SUBSIZED}, then {@code estimateSize()}
     * for this spliterator before splitting must be equal to the sum of
     * {@code estimateSize()} for this and the returned Spliterator after
     * splitting.</li>
     * </ul>
     *
     * <p>This method may return {@code null} for any reason,
     * including emptiness, inability to split after traversal has
     * commenced, data structure constraints, and efficiency
     * considerations.
     *
     * @apiNote
     * An ideal {@code trySplit} method efficiently (without
     * traversal) divides its elements exactly in half, allowing
     * balanced parallel computation.  Many departures from this ideal
     * remain highly effective; for example, only approximately
     * splitting an approximately balanced tree, or for a tree in
     * which leaf nodes may contain either one or two elements,
     * failing to further split these nodes.  However, large
     * deviations in balance and/or overly inefficient {@code
     * trySplit} mechanics typically result in poor parallel
     * performance.

    尝试对Spliterator中元素进行trySplit
        若能进行拆分，则返回一个新的Spliterator对象 装载已分割的元素
        如果分割前有序，分割后也是有序的
        分割结果不为null:
            进行有限分割后 最终能得到非null元素
        分割结果为null:
            对有限元素个数的分割：进行无限分割
            分割前元素个数为null
            遍历开始后无法拆分  数据结构约束 性能考量

    Spliterator<T> trySplit();


     * Returns an estimate of the number of elements that would be
     * encountered by a {@link #forEachRemaining} traversal, or returns {@link
     * Long#MAX_VALUE} if infinite, unknown, or too expensive to compute.
     *
     * <p>If this Spliterator is {@link #SIZED} and has not yet been partially
     * traversed or split, or this Spliterator is {@link #SUBSIZED} and has
     * not yet been partially traversed, this estimate must be an accurate
     * count of elements that would be encountered by a complete traversal.
     * Otherwise, this estimate may be arbitrarily inaccurate, but must decrease
     * as specified across invocations of {@link #trySplit}.
     *
     * @apiNote
     * Even an inexact estimate is often useful and inexpensive to compute.
     * For example, a sub-spliterator of an approximately balanced binary tree
     * may return a value that estimates the number of elements to be half of
     * that of its parent; if the root Spliterator does not maintain an
     * accurate count, it could estimate size to be the power of two
     * corresponding to its maximum depth.

    估算元素数量（即将遍历的元素个数）
    如果元素数量无限 未知 或计算成本很昂贵  返回Long.Max_Value
    如果Spliterator是一个SIZED或SUBSIZED estimate则是完整遍历所需要的值（accurate精确）
    long estimateSize();


     * Convenience method that returns {@link #estimateSize()} if this
     * Spliterator is {@link #SIZED}, else {@code -1}.

    characteristic.SIZED -->返回确定的大小  否则为 -1L
    default long getExactSizeIfKnown() {
        return (characteristics() & SIZED) == 0 ? -1L : estimateSize();
    }


     * Returns a set of characteristics of this Spliterator and its
     * elements. The result is represented as ORed values from {@link
     * #ORDERED}, {@link #DISTINCT}, {@link #SORTED}, {@link #SIZED},
     * {@link #NONNULL}, {@link #IMMUTABLE}, {@link #CONCURRENT},
     * {@link #SUBSIZED}.  Repeated calls to {@code characteristics()} on
     * a given spliterator, prior to or in-between calls to {@code trySplit},
     * should always return the same result.
     *
     * <p>If a Spliterator reports an inconsistent set of
     * characteristics (either those returned from a single invocation
     * or across multiple invocations), no guarantees can be made
     * about any computation using this Spliterator.
     *
     * @apiNote The characteristics of a given spliterator before splitting
     * may differ from the characteristics after splitting.  For specific
     * examples see the characteristic values {@link #SIZED}, {@link #SUBSIZED}
     * and {@link #CONCURRENT}.
     *
     * @return a representation of characteristics

    返回Spliterator与其元素的一个特性值标识
    在分割期间或之前 其元素的特性不变
    分割前后若元素的特性发生了变更 对其进行计算行为是不能受到保证的
    int characteristics();


     * Returns {@code true} if this Spliterator's {@link
     * #characteristics} contain all of the given characteristics.

    判断是否包含此元素特性
    default boolean hasCharacteristics(int characteristics) {
        return (characteristics() & characteristics) == characteristics;
    }


     * If this Spliterator's source is {@link #SORTED} by a {@link Comparator},
     * returns that {@code Comparator}. If the source is {@code SORTED} in
     * {@linkplain Comparable natural order}, returns {@code null}.  Otherwise,
     * if the source is not {@code SORTED}, throws {@link IllegalStateException}.
    如果source是有序的：
            如果是按照比较器进行排序         则返回该比较器
            如果是Comparable natural order 则返回null
    如果source是无序的 抛出IllegalStateException异常
    default Comparator<? super T> getComparator() {
        throw new IllegalStateException();
    }




     * A Spliterator specialized for primitive values.
     * 针对于原生类型值的特化分割器
     *
     * @param <T> the type of elements returned by this Spliterator.
     * The type must be a wrapper type for a primitive type,
     * such as {@code Integer} for the primitive {@code int} type.
     * @param <T_CONS> the type of primitive consumer.  The type must be a
     * primitive specialization of {@link java.util.function.Consumer} for
     * {@code T}, such as {@link java.util.function.IntConsumer} for {@code Integer}.
     * @param <T_SPLITR> the type of primitive Spliterator.  The type must be
     * a primitive specialization of Spliterator for {@code T}, such as
     * {@link Spliterator.OfInt} for {@code Integer}.
     *
     * @see Spliterator.OfInt
     * @see Spliterator.OfLong
     * @see Spliterator.OfDouble
     * @since 1.8
     *  T        Spliterator返回的元素类型：原生包装类型
     *  T_CONS   primitive consumer    ：java.util.function.IntConsumer对Integer的原生特化
     *  T_SPLITR primitive Spliterator ：Spliterator.OfInt对Integer的原生特化
     *

    public interface OfPrimitive<T, T_CONS, T_SPLITR extends Spliterator.OfPrimitive<T, T_CONS, T_SPLITR>>
            extends Spliterator<T> {
        @Override
        T_SPLITR trySplit();

        @SuppressWarnings("overloads")
        boolean tryAdvance(T_CONS action);

        @SuppressWarnings("overloads")
        default void forEachRemaining(T_CONS action) {
            do { } while (tryAdvance(action));
        }
    }


     * A Spliterator specialized for {@code int} values.
     * @since 1.8
    public interface OfInt extends OfPrimitive<Integer, IntConsumer, OfInt> {

        @Override
        OfInt trySplit();

        @Override
        boolean tryAdvance(IntConsumer action);

        @Override
        default void forEachRemaining(IntConsumer action) {
            do { } while (tryAdvance(action));
        }

五、Consumer 与 IntConsumer、LongConsumer、DoubleConsumer

        五、Consumer 与 IntConsumer、LongConsumer、DoubleConsumer

        // Consumer 与 IntConsumer 为什么能进行强制类型转换？
        // Consumer 与 IntConsumer 之间没有继承关系 层次上无关系
        // Consumer 与 IntConsumer 当传入的参数是整型int,Integer时 会自动进行装箱拆箱
        // ((IntConsumer) action::accept) 是Lambda表达式
        // Lambda表达式 是一种匿名函数 没有方法声明 具有上下文自动推测类型功能

         * {@inheritDoc}
         * @implSpec
         * If the action is an instance of {@code IntConsumer} then it is cast
         * to {@code IntConsumer} and passed to
         * {@link #tryAdvance(java.util.function.IntConsumer)}; otherwise
         * the action is adapted to an instance of {@code IntConsumer}, by
         * boxing the argument of {@code IntConsumer}, and then passed to
         * {@link #tryAdvance(java.util.function.IntConsumer)}.

        @Override
        default boolean tryAdvance(Consumer<? super Integer> action) {
            if (action instanceof IntConsumer) {
                return tryAdvance((IntConsumer) action);
            }
            else {
                if (Tripwire.ENABLED)
                    Tripwire.trip(getClass(),
                            "{0} calling Spliterator.OfInt.tryAdvance((IntConsumer) action::accept)");
                return tryAdvance((IntConsumer) action::accept);
            }
        }


         * {@inheritDoc}
         * @implSpec
         * If the action is an instance of {@code IntConsumer} then it is cast
         * to {@code IntConsumer} and passed to
         * {@link #forEachRemaining(java.util.function.IntConsumer)}; otherwise
         * the action is adapted to an instance of {@code IntConsumer}, by
         * boxing the argument of {@code IntConsumer}, and then passed to
         * {@link #forEachRemaining(java.util.function.IntConsumer)}.

        @Override
        default void forEachRemaining(Consumer<? super Integer> action) {
            if (action instanceof IntConsumer) {
                forEachRemaining((IntConsumer) action);
            }
            else {
                if (Tripwire.ENABLED)
                    Tripwire.trip(getClass(),
                            "{0} calling Spliterator.OfInt.forEachRemaining((IntConsumer) action::accept)");
                forEachRemaining((IntConsumer) action::accept);
            }
        }
    }


     * A Spliterator specialized for {@code long} values.
     * @since 1.8

    public interface OfLong extends OfPrimitive<Long, LongConsumer, OfLong> {

        @Override
        OfLong trySplit();

        @Override
        boolean tryAdvance(LongConsumer action);

        @Override
        default void forEachRemaining(LongConsumer action) {
            do { } while (tryAdvance(action));
        }


         * {@inheritDoc}
         * @implSpec
         * If the action is an instance of {@code LongConsumer} then it is cast
         * to {@code LongConsumer} and passed to
         * {@link #tryAdvance(java.util.function.LongConsumer)}; otherwise
         * the action is adapted to an instance of {@code LongConsumer}, by
         * boxing the argument of {@code LongConsumer}, and then passed to
         * {@link #tryAdvance(java.util.function.LongConsumer)}.

        @Override
        default boolean tryAdvance(Consumer<? super Long> action) {
            if (action instanceof LongConsumer) {
                return tryAdvance((LongConsumer) action);
            }
            else {
                if (Tripwire.ENABLED)
                    Tripwire.trip(getClass(),
                            "{0} calling Spliterator.OfLong.tryAdvance((LongConsumer) action::accept)");
                return tryAdvance((LongConsumer) action::accept);
            }
        }


         * {@inheritDoc}
         * @implSpec
         * If the action is an instance of {@code LongConsumer} then it is cast
         * to {@code LongConsumer} and passed to
         * {@link #forEachRemaining(java.util.function.LongConsumer)}; otherwise
         * the action is adapted to an instance of {@code LongConsumer}, by
         * boxing the argument of {@code LongConsumer}, and then passed to
         * {@link #forEachRemaining(java.util.function.LongConsumer)}.

        @Override
        default void forEachRemaining(Consumer<? super Long> action) {
            if (action instanceof LongConsumer) {
                forEachRemaining((LongConsumer) action);
            }
            else {
                if (Tripwire.ENABLED)
                    Tripwire.trip(getClass(),
                            "{0} calling Spliterator.OfLong.forEachRemaining((LongConsumer) action::accept)");
                forEachRemaining((LongConsumer) action::accept);
            }
        }
    }


     * A Spliterator specialized for {@code double} values.
     * @since 1.8

    public interface OfDouble extends OfPrimitive<Double, DoubleConsumer, OfDouble> {

        @Override
        OfDouble trySplit();

        @Override
        boolean tryAdvance(DoubleConsumer action);

        @Override
        default void forEachRemaining(DoubleConsumer action) {
            do { } while (tryAdvance(action));
        }


         * {@inheritDoc}
         * @implSpec
         * If the action is an instance of {@code DoubleConsumer} then it is
         * cast to {@code DoubleConsumer} and passed to
         * {@link #tryAdvance(java.util.function.DoubleConsumer)}; otherwise
         * the action is adapted to an instance of {@code DoubleConsumer}, by
         * boxing the argument of {@code DoubleConsumer}, and then passed to
         * {@link #tryAdvance(java.util.function.DoubleConsumer)}.

        @Override
        default boolean tryAdvance(Consumer<? super Double> action) {
            if (action instanceof DoubleConsumer) {
                return tryAdvance((DoubleConsumer) action);
            }
            else {
                if (Tripwire.ENABLED)
                    Tripwire.trip(getClass(),
                            "{0} calling Spliterator.OfDouble.tryAdvance((DoubleConsumer) action::accept)");
                return tryAdvance((DoubleConsumer) action::accept);
            }
        }


         * {@inheritDoc}
         * @implSpec
         * If the action is an instance of {@code DoubleConsumer} then it is
         * cast to {@code DoubleConsumer} and passed to
         * {@link #forEachRemaining(java.util.function.DoubleConsumer)};
         * otherwise the action is adapted to an instance of
         * {@code DoubleConsumer}, by boxing the argument of
         * {@code DoubleConsumer}, and then passed to
         * {@link #forEachRemaining(java.util.function.DoubleConsumer)}.

        @Override
        default void forEachRemaining(Consumer<? super Double> action) {
            if (action instanceof DoubleConsumer) {
                forEachRemaining((DoubleConsumer) action);
            }
            else {
                if (Tripwire.ENABLED)
                    Tripwire.trip(getClass(),
                            "{0} calling Spliterator.OfDouble.forEachRemaining((DoubleConsumer) action::accept)");
                forEachRemaining((DoubleConsumer) action::accept);
            }
        }
    }
}*/

六、Consumer 与 IntConsumer 的强制类型转换测试

// 六、Consumer 与 IntConsumer 的强制类型转换测试
// 传入面向对象   对象
this.action(intConsumer);

// 传入Lambda表达式 函数式编程
this.action(intConsumer::accept);
this.action(value -> intConsumer.accept(value));

this.action(consumer::accept);
this.action(value -> consumer.accept(value));

// 面向对象强制类型转换 报错java.lang.ClassCastException
// this.action((IntConsumer) consumer);
// this.action(((IntConsumer) consumer)::accept);
// this.action(t -> ((IntConsumer) consumer).accept(t));

// 函数式编程强制类型转换 Lambda表达式没变
this.action((IntConsumer) consumer::accept);
this.action((IntConsumer) (t -> consumer.accept(t)));
this.action((IntConsumer) t -> consumer.accept(t));

七、Iterator-based Spliterators 与 StreamSupport底层实现

// 七、Iterator-based Spliterators 与 StreamSupport底层实现

// Iterator-based Spliterators

/*
 * A Spliterator using a given Iterator for element
 * operations. The spliterator implements {@code trySplit} to
 * permit limited parallelism.
 * spliterator利用trySplit实现有限的并行化操作
 *
 * static class IteratorSpliterator<T> implements Spliterator<T> {}
 */


/*
 * Low-level utility methods for creating and manipulating streams.
 * 用于创建和操作流的底层实用程序方法
 *
 * <p>This class is mostly for library writers presenting stream views
 * of data structures; most static stream methods intended for end users are in
 * the various {@code Stream} classes.
 * StreamSupport提供数据结构的流视图的library  大多数为终端用户使用的静态流方法在Stream类中
 *
 * @since 1.8
 *

     public final class StreamSupport {

     * Creates a new sequential or parallel {@code Stream} from a
     * {@code Spliterator}.
     *
     *
     * <p>The spliterator is only traversed, split, or queried for estimated
     * size after the terminal operation of the stream pipeline commences.
     * 仅在流管道的终端操作开始后，才遍历、拆分或查询spliterator的估计大小。
     *
     * <p>It is strongly recommended the spliterator report a characteristic of
     * {@code IMMUTABLE} or {@code CONCURRENT}, or be
     * <a href="../Spliterator.html#binding">late-binding</a>.  Otherwise,
     * {@link #stream(java.util.function.Supplier, int, boolean)} should be used
     * to reduce the scope of potential interference with the source.  See
     * <a href="package-summary.html#NonInterference">Non-Interference</a> for
     * more details.
     * 强烈建议对spliterator设置characteristic（IMMUTABLE  CONCURRENT late-binding）
     * 以减少潜在的干扰源范围
     *

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


}*/

八、流源分析

 // 八、流源分析
 /*
 流源的创建

 Abstract base class for an intermediate pipeline stage or pipeline source
 stage implementing whose elements are of type {@code U}.
 抽象基类：用于实现其元素类型为{@code U}的中间管道阶段或管道源阶段
 ReferencePipeline 操作引用类型 （将源阶段 与 [0,n)个中间操作阶段 看做一个对象）


 * @param <P_IN>  type of elements in the upstream source
 * @param <P_OUT> type of elements in produced by this stage

  abstract class ReferencePipeline<P_IN, P_OUT>
         extends AbstractPipeline<P_IN, P_OUT, Stream<P_OUT>>
         implements Stream<P_OUT>  {


 * 源阶段
 * Source stage of a ReferencePipeline.
 *
 * @param <E_IN> type of elements in the upstream source
 * @param <E_OUT> type of elements in produced by this stage

 ReferencePipeline中静态内部类Head
 static class Head<E_IN, E_OUT> extends ReferencePipeline<E_IN, E_OUT>

 *
 * 注意：
 *     流本身不持有数据
 *     数据的持有者：流的数据源（集合、数组等）
 *     流关注对数据的计算
 */


/* 抽象基类: 抽象管道AbstractPipeline 流接口及 其特化的核心实现
            管理流管道 创建 与 评估
 * Abstract base class for "pipeline" classes, which are the core
 * implementations of the Stream interface and its primitive specializations.
 * Manages construction and evaluation of stream pipelines.
 *
 * <p>A concrete intermediate stage is generally built from an
 * {@code AbstractPipeline}, a shape-specific pipeline class which extends it
 * (e.g., {@code IntPipeline}) which is also abstract, and an operation-specific
 * concrete class which extends that.  {@code AbstractPipeline} contains most of
 * the mechanics of evaluating the pipeline, and implements methods that will be
 * used by the operation; the shape-specific classes add helper methods for
 * dealing with collection of results into the appropriate shape-specific
 * containers.
 *
 *
 * <p>After chaining a new intermediate operation, or executing a terminal
 * operation, the stream is considered to be consumed, and no more intermediate
 * or terminal operations are permitted on this stream instance.
 * 在链式添加中间操作或一个终止操作后 流视做被消费
 * 流只能被消费一次  已消费-->不允许在此流实例中存在更多的中间操作或终止操作
 *
 * @implNote
 * <p>For sequential streams, and parallel streams without
 * <a href="package-summary.html#StreamOps">stateful intermediate
 * operations</a>, parallel streams, pipeline evaluation is done in a single
 * pass that "jams" all the operations together.  For parallel streams with
 * stateful operations, execution is divided into segments, where each
 * stateful operations marks the end of a segment, and each segment is
 * evaluated separately and the result used as the input to the next
 * segment.  In all cases, the source data is not consumed until a terminal
 * operation begins.
 * 串行流 与 无状态的并行流
 * 流的消费 是将中间的操作进行“jams”（打包放一起）对流中每个元素执行action-->single pass
 *
 * 有状态的并行流
 * 执行分成segments 分别对segment执行有状态操作 并将其结果作为下一个segment输入
 *
 * 在任何情况下，有且只有在一个终止操作被调用时 流真正被消费

 abstract class AbstractPipeline<E_IN, E_OUT, S extends BaseStream<E_OUT, S>>
         extends PipelineHelper<E_OUT> implements BaseStream<E_OUT, S>



 AbstractPipeline的构造方法
 AbstractPipeline(Supplier<? extends Spliterator<?>> source,
 int sourceFlags, boolean parallel) {}

 AbstractPipeline(Spliterator<?> source,
 int sourceFlags, boolean parallel) {}

 同一时间构造同一个AbstractPipeline 有且只有调用AbstractPipeline构造方法之一
 sourceSpliterator与sourceSupplier
               同一时间只能存在其一
               当流被消费后 若not null 要设置为null
               只能被消费一次
 private Spliterator<?> sourceSpliterator;
 private Supplier<? extends Spliterator<?>> sourceSupplier;

 */

/*


 针对于流源的foreach
 Optimized sequential terminal operations for the head of the pipeline
 @Override
 public void forEach(Consumer<? super E_OUT> action) {
     if (!isParallel()) {
         sourceStageSpliterator().forEachRemaining(action);
     }
     else {
         super.forEach(action);
     }
 }


 Terminal operations from Stream
 @Override
 public void forEach(Consumer<? super P_OUT> action) {
     evaluate(ForEachOps.makeRef(action, false));
 }

 */

九、Array.asList()流源遍历注意事项

        // 九、Array.asList()流源遍历注意事项

        /*
        为什么 未调用IteratorSpliterator.forEachRemaining()
        list.stream().forEach(System.out::println); 执行过程分析

        Arrays.asList()

        private static class ArrayList<E> extends AbstractList<E> implements RandomAccess, java.io.Serializable{

        private final E[] a;

        ArrayList(E[] array) {
            a = Objects.requireNonNull(array);
            }

        @Override
        public Spliterator<E> spliterator() {
            return Spliterators.spliterator(a, Spliterator.ORDERED);
            }

        }

        public static <T> Spliterator<T> spliterator(Object[] array,
        int additionalCharacteristics) {
            return new ArraySpliterator<>(Objects.requireNonNull(array),
                    additionalCharacteristics);
        }

        @Override
        public void forEach(Consumer<? super E_OUT> action) {
            if (!isParallel()) {
                sourceStageSpliterator().forEachRemaining(action);
            }
            else {
                super.forEach(action);
            }
        }

        @SuppressWarnings("unchecked")
        @Override
        public void forEachRemaining(Consumer<? super T> action) {
            Object[] a; int i, hi; // hoist accesses and checks from loop
            if (action == null)
                throw new NullPointerException();
            if ((a = array).length >= (hi = fence) &&
                    (i = index) >= 0 && i < (index = hi)) {
                do { action.accept((T)a[i]); } while (++i < hi);
            }
        }*/


        System.out.println(list.getClass());

        // Arrays中静态内部类ArrayList (class java.util.Arrays$ArrayList)
        // @Override public Spliterator<E> spliterator(){}
        // 调用ArraySpliterator.forEachRemaining()实现
        list.stream().forEach(System.out::println);

        // 普通集合遍历 Iterable 中的 forEach
        // 效率高
        list.forEach(System.out::println);


    }
}

十、测试结果

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::        (v2.1.2.RELEASE)

2019-02-20 18:09:13.662  INFO 2224 --- [           main] c.j.d.j.S.S.B.SpliteratorDetail          : Starting SpliteratorDetail on DESKTOP-87RMBG4 with PID 2224 (started by 46250 in E:\IdeaProjects\design)
2019-02-20 18:09:13.663  INFO 2224 --- [           main] c.j.d.j.S.S.B.SpliteratorDetail          : No active profile set, falling back to default profiles: default
2019-02-20 18:09:14.133  INFO 2224 --- [           main] c.j.d.j.S.S.B.SpliteratorDetail          : Started SpliteratorDetail in 0.653 seconds (JVM running for 1.335)

100
100
100
100
100
100
100
100

class java.util.Arrays$ArrayList

Kirito
Asuna
Sinon
Yuuki
Alice

Kirito
Asuna
Sinon
Yuuki
Alice