java源码品读（9）— Spliterator

Spliterator接口是1.8新加的接口，字面意思可分割的迭代器，不同以往的iterator需要顺序迭代，Spliterator可以分割为若干个小的迭代器进行并行操作，既可以实现多线程操作提高效率，又可以避免普通迭代器的fail-fast机制所带来的异常。Spliterator可以配合1.8新加的Stream进行并行流的实现，大大提高处理效率。

我们先看Spliterator接口的几个方法，然后结合我们之前看过的ArrayList中实现的ArrayListSpliterator进一步理解Spliterator：

属性

通过characteristics（）方法返回的值，用来标识实现类所具有的的特征

public static final int ORDERED    = 0x00000010;//表示元素是有序的（每一次遍历结果相同）
public static final int DISTINCT   = 0x00000001;//表示元素不重复
public static final int SORTED     = 0x00000004;//表示元素是按一定规律进行排列（有指定比较器）
public static final int SIZED      = 0x00000040;//是否确定大小
public static final int NONNULL    = 0x00000100;//表示迭代器中没有null元素
public static final int IMMUTABLE  = 0x00000400;//表示元素不可变
public static final int CONCURRENT = 0x00001000;//表示迭代器可以多线程操作
public static final int SUBSIZED   = 0x00004000;//表示子Spliterators都具有SIZED特性

方法

• boolean tryAdvance(Consumer action);
  如果有剩余的元素存在，执行参数给定的操作，并返回true，否则就返回false。
  如果Spliterator对象具有ORDERED属性，那么tryAdvance也会按照相应的顺序去执行。

• default void forEachRemaining(Consumer action)
  对Spliterator的每一个对象执行tryAdvance操作

default void forEachRemaining(Consumersuper T> action) {
        do { } while (tryAdvance(action));
    }

• Spliterator trySplit();
  如果这个Spliterator是可以被分割的，那么这个方法会返回一个Spliterator，与原来的Spliterator平分其中的元素，如果原Spliterator的元素个数单数，两个Spliterator的元素个数相差1，基本是相同的。
  如果Spliterator不能再分割，那么会返回null

• long estimateSize()
  返回一个预估的值，等于执行forEachRemaining方法时调用tryAdvance的次数。
  如果这个值过大，或者需要太复杂的计算过程，那么直接回返回long型的最大值

• default long getExactSizeIfKnown()
  返回Spliterator对象确切的大小，如果存在SIZED属性，则返回estimateSize()方法的返回值，否则返回-1

default long getExactSizeIfKnown() {
        return (characteristics() & SIZED) == 0 ? -1L : estimateSize();
    }

• int characteristics();
  返回Spliterator对象的特征值，这个上面有介绍。一般实现类中的属性就是几个属性进行或操作之后的结果。

• default boolean hasCharacteristics(int characteristics)
  根据characteristics()与参数相与的结果看Spliterator对象是否包含参数指定的属性

default boolean hasCharacteristics(int characteristics) {
        return (characteristics() & characteristics) == characteristics;
}

• default Comparator getComparator()
  如果Spliterator的具体实现具有SORTED属性，那么此方法会返回一个相应的比较器，否则会返回null

default Comparatorsuper T> getComparator() {
    throw new IllegalStateException();
}

衍生接口

• OfPrimitive
  衍生借口的内容与Spliterator几乎无差别，只是将trySplit，tryAdvance，forEachRemaining三个方法中的参数类型做了一点小小的变化，更加适合基本参数类型。

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

下面有相应的OfInt、OfLong、OfDouble三个借口专门提供给int、long、double类型的数据使用。

ArrayListSpliterator

接下来我们来看一看ArrayList中的具体实现ArrayListSpliterator，更进一步去理解一下这个接口

static final class ArrayListSpliterator<E> implements Spliterator<E>{}   
        private final ArrayList list;//存储元素的list
        private int index; // 起始位置（当前的索引），可能被trySplit和tryAdvance操作修改
        private int fence; // 结束位置，ArrayListSpliterator未使用前为-1，使用后为list的size
        private int expectedModCount; //跟fence方法一样在getFence方法中进行初始化，值跟list的modCount一样

        ArrayListSpliterator(ArrayList list, int origin, int fence, int expectedModCount) {
            this.list = list;
            this.index = origin;// 迭代器的起始位置
            this.fence = fence;// 
            //初始无所谓，ArrayListSpliterator操作之后会跟list的modCount保持一致
            this.expectedModCount = expectedModCount;
        }
        // 获取结束位置：初始化对象的fence属性，list不为null同时初始化expectedModCount属性
        private int getFence() { 
            int hi;
            ArrayList lst;
            if ((hi = fence) < 0) {//-1的时候才会对fence进行初始化
                if ((lst = list) == null)
                    hi = fence = 0;
                else {
                    expectedModCount = lst.modCount;
                    hi = fence = lst.size;
                }
            }
            return hi;
        }
        public ArrayListSpliterator trySplit() {
            int hi = getFence(), lo = index, mid = (lo + hi) >>> 1;
            //可再分，产生新的ArrayListSpliterator，不能再分返回null
            return (lo >= mid) ? null :  
                    new ArrayListSpliterator(list, lo, index = mid, expectedModCount);
        }        
        public boolean tryAdvance(Consumersuper E> action) {
            if (action == null)
                throw new NullPointerException();
            int hi = getFence(), i = index;
            if (i < hi) {
                index = i + 1;//每正常执行一次，下标后移
                @SuppressWarnings("unchecked") E e = (E)list.elementData[i];
                action.accept(e);
                if (list.modCount != expectedModCount)//modcount检验：使用过程中禁止对list进行结构操作
                    throw new ConcurrentModificationException();
                return true;//还有元素返回true
            }
            return false;//没有元素返回false
        }
        //对每一个元素进行操作，    
        public void forEachRemaining(Consumersuper E> action) {
            int i, hi, mc; // hoist accesses and checks from loop
            ArrayList lst; Object[] a;
            if (action == null)
                throw new NullPointerException();
            if ((lst = list) != null && (a = lst.elementData) != null) {
                if ((hi = fence) < 0) {//fence小于0表示首次使用，expectedModCount和fence属性未进行初始化
                    mc = lst.modCount;
                    hi = lst.size;
                }
                else
                    mc = expectedModCount;
                if ((i = index) >= 0 && (index = hi) <= a.length) {
                    for (; i < hi; ++i) {
                        @SuppressWarnings("unchecked") E e = (E) a[i];
                        action.accept(e);
                    }
                    if (lst.modCount == mc)
                        return;//所有元素循环完之后确定结构未发生变化，否则抛错
                }
            }
            throw new ConcurrentModificationException();
        }
        //返回forEachRemaining方法循环的次数
        public long estimateSize() {
            return (long) (getFence() - index);
        }
        //ArrayListSpliterator具有有序，确定大小的特点，衍生出来的子比较器同样确定大小
        public int characteristics() {
            return Spliterator.ORDERED | Spliterator.SIZED | Spliterator.SUBSIZED;
        }
    }