集合源码学习(四):Vector

Vector是什么？

Vector是一个集合，和在实现结构上和ArrayList很相似，包括增加，修改，删除等等操作，和ArrayList实现算法均一致。所以本篇博文不再像前一篇文章集合源码学习(三):ArrayList 般介绍具体实现类型方方面面。所以想继续了解Vector源码读者可以先看ArrayList这篇，再来读这篇就可以了。
而与ArrayList的最大不同点，就是Vector里面的方法都考虑了线程安全，在很多操作方法上都加了synchronized关键字
这篇文章主要分享一些不同与ArrayList特点的地方。

定义头

public class Vector<E>    extends AbstractList<E>    implements List<E>, RandomAccess, Cloneable, java.io.Serializable

同样是可随机访问以及可克隆，继承子AbstractList等。

初始值以及扩容

关于扩容，在数值上和ArrayList并不相同，如果程序员没有指定初值Vector的大小，则默认为10，而在扩容方面，Vector则是用一个capacityIncrement来确定的，同时也要和程序员要求扩容大小来比较，具体看代码及注释：

  /**     * 初始值为设置值，增长值为0默认     */    public Vector(int initialCapacity) {        this(initialCapacity, 0);    }    /**     * 初始值为10,默认增长值为0.     */    public Vector() {        this(10);    }

接下来是关于扩容方面：
依次调用ensureCapacity，ensureCapacityHelper，grow等方法，中间除了一些边界判断语句，基本都是层层嵌套，这里主要贴出grow方法代码：

    private void grow(int minCapacity) {        // overflow-conscious code        int oldCapacity = elementData.length;        //由此可见，如果capacityIncrement>0,就会按照cpacityIncrement大小增加，否则就是2个oldCapacity。        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?                                         capacityIncrement : oldCapacity);        //如果min比调整后的大小还大，那就按照minCapacity来。        if (newCapacity - minCapacity < 0)            newCapacity = minCapacity;        if (newCapacity - MAX_ARRAY_SIZE > 0)            newCapacity = hugeCapacity(minCapacity);        elementData = Arrays.copyOf(elementData, newCapacity);    }

Collections里面的线程安全包装方法

Vector里面也有个subList方法来获得子串，但是与ArrayList的实现不同，因为它被设计为线程安全的，所以直接返回了一个线程安全的包装类，这里介绍一下基本原理。
第一步：

public synchronized List<E> subList(int fromIndex, int toIndex) {        return Collections.synchronizedList(super.subList(fromIndex, toIndex),                                            this);    }

接下来进入Collections.synchronized查看：

static <T> List<T> synchronizedList(List<T> list, Object mutex) {        return (list instanceof RandomAccess ?                new SynchronizedRandomAccessList<>(list, mutex) :                new SynchronizedList<>(list, mutex));    }

返回了一个SynchronizedRandomAccessList，那再去看这个类。

static class SynchronizedRandomAccessList<E>        extends SynchronizedList<E>        implements RandomAccess {        ...SynchronizedRandomAccessList(List<E> list, Object mutex) {            super(list, mutex);        }

这个类完全指示对super的一个包装SynchronizedList，已看名字就知道是一个线程安全类：

    ...    final List<E> list;        SynchronizedList(List<E> list) {            super(list);            this.list = list;        }        SynchronizedList(List<E> list, Object mutex) {            super(list, mutex);            this.list = list;        }        public boolean equals(Object o) {            if (this == o)                return true;            synchronized (mutex) {return list.equals(o);}        }        public int hashCode() {            synchronized (mutex) {return list.hashCode();}        }        public E get(int index) {            synchronized (mutex) {return list.get(index);}        }        public E set(int index, E element) {            synchronized (mutex) {return list.set(index, element);}        }        public void add(int index, E element) {            synchronized (mutex) {list.add(index, element);}        }    ...

可以发现里面有众多方法，并且都是Vector中操作名字相同的方法，指示都是对当前Vector加锁，再进行操作的线程安全方法。
而其中方法实现原理，都是基于适配器模式间接使用Vector来进行操作，这是典型java多态的应用，如果通过debug源码，可以很清楚的看清这一点。
以上就是Collections里面synchronizedList包装方法的原理，其他方法可以类比理解。

Vector里面的Spliterator-VectorSpliterator

或许会有一个疑问，Vector不是线程安全的么？为啥也有Spliterator？
对于Spliterator不懂的读者可以看我这篇文章：集合源码学习(二):Spliterator
Spliterator可是一个支持并行的迭代器啊。
不多说，先看看源码：

  static final class VectorSpliterator<E> implements Spliterator<E> {        private final Vector<E> list;        private Object[] array;        private int index; // current index, modified on advance/split        private int fence; // -1 until used; then one past last index        private int expectedModCount; // initialized when fence set        ...    这些和ArrayListSpliterator没有特别之处，就不多说    ...        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)                    throw new ConcurrentModificationException();                return true;            }            return false;        }        //forEachRemaining方法和tryAdvance原理类似

和ArrayListSpliterator一样，也会有expectedModCount来保证fast-fail机制，防止在通过迭代器遍历的时候，Vector结构突然被改变(add和remove)。而不同的是，VectorSpliterator还传入了一个Object[]数组，java里面数组也是引用类型，也就是把Vector中的elementData传进来了。这样在tryAdvance中，就可以获得Vector中元素了Vector中get方法是同步的），也就可以进行并行的tryAdvance和forEachRemaining操作了。

确实在Vector上收获蛮多喔^^