【Java基础】Spliterator

Spliterator接口是1.8新加的不包含重复元素的集合。更正式地说，集合不包含元素对e1和e2，使得e1.equals(e2)和至多一个null元素。字面意思可分割的迭代器，不同以往的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<? super T> action);
  如果有剩余的元素存在，执行参数给定的操作，并返回true，否则就返回false。
  如果Spliterator对象具有ORDERED属性，那么tryAdvance也会按照相应的顺序去执行。

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

	default void forEachRemaining(Consumer<? super 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<? super T> getComparator()
  如果Spliterator的具体实现具有SORTED属性，那么此方法会返回一个相应的比较器，否则会返回null

	default Comparator<? super 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<E> list;//存储元素的list
    private int index; // 起始位置（当前的索引），可能被trySplit和tryAdvance操作修改
    private int fence; // 结束位置，ArrayListSpliterator未使用前为-1，使用后为list的size
    private int expectedModCount; //跟fence方法一样在getFence方法中进行初始化，值跟list的modCount一样

    ArrayListSpliterator(ArrayList<E> 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<E> 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<E> trySplit() {
        int hi = getFence(), lo = index, mid = (lo + hi) >>> 1;
        //可再分，产生新的ArrayListSpliterator，不能再分返回null
        return (lo >= mid) ? null :  
                new ArrayListSpliterator<E>(list, lo, index = mid, expectedModCount);
    }        
    public boolean tryAdvance(Consumer<? super 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(Consumer<? super E> action) {
        int i, hi, mc; // hoist accesses and checks from loop
        ArrayList<E> 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;
    }
}