【小笨鸟看JDK1.7集合源码之四】Vector源码剖析

Vector 简介

(1)Vector类也是以数组结构为基础，可以直接使用数组索引进行访问，但是它具有可自由增长的特性；

(2)实现了RandomAccess支持随机访问，Cloneable可以实现克隆，Serializable能够被序列化；

(3)Vector其实与ArrayList功能类似，但是加入了很多同步语句，因此是线程安全的，适用于多线程环境；但是因为加了同步之后效率会相应降低。

JDK1.7-LinkedList源码详细分析

public class Vector<E>
    extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    /**
     * 数组缓冲区，用于存放vector中的元素
     */
    protected Object[] elementData;

    /**
     *元素个数，Vector 对象中的有效组件数。从 elementData[0] 到 elementData[elementCount-1] 
     的组件均为实际项。 
     */
    protected int elementCount;

    /**
     *向量的大小大于其容量时，容量自动增加的量。
     如果容量的增量小于等于零，则每次需要增大容量时，向量的容量将增大一倍，
     代表的是一个变化的增量，是在扩容时计算；
     */
    protected int capacityIncrement;

    /** use serialVersionUID from JDK 1.0.2 for interoperability */
    private static final long serialVersionUID = -2767605614048989439L;
    
    /**
    构造函数
    initialCapacity：初始容量
    capacityIncrement：容量的增量
    */
    public Vector(int initialCapacity, int capacityIncrement) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        this.elementData = new Object[initialCapacity];//初始化
        this.capacityIncrement = capacityIncrement;
    }
    //不带增量的构造函数
    public Vector(int initialCapacity) {
        this(initialCapacity, 0);
    }
    //无参构造函数，默认初始化容量为10，标准容量增量为0
    public Vector() {
        this(10);
    }
    /**构造一个包含指定collection中的元素的向量vector*/
    public Vector(Collection<? extends E> c) {
        elementData = c.toArray();//获取元素数组
        elementCount = elementData.length;//数组长度
        // c.toArray might (incorrectly) not return Object[] (see 6260652)
        //可能返回的是非数组的对象
        if (elementData.getClass() != Object[].class)//如果非数组类型的对象
            //重新复制构造一个新的数组
            elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
    }
    /**将向量复制到指定的参数数组中，此方法是同步的
        复制默认从第一个元素开始，长度为vector中的元素个数，全部复制到参数anArray中；
        如果参数数组为空或者容量不够、存储类型异常，会抛出相应异常
    */
    public synchronized void copyInto(Object[] anArray) {
        System.arraycopy(elementData, 0, anArray, 0, elementCount);
    }
    /**
     * 调整向量的实际容量，如果当前向量容量大于其当前大小，则通过复制数组的方式将
     容量更改为当前的实际大小。其实就是根据当前容量与向量元素的实际个数不等时作出相应的
     调整；
     */
    public synchronized void trimToSize() {
        modCount++;
        int oldCapacity = elementData.length;
        if (elementCount < oldCapacity) {
            elementData = Arrays.copyOf(elementData, elementCount);
        }
    }
    /**
     * 确认容量，是否能容纳指定参数大小的容量
     */
    public synchronized void ensureCapacity(int minCapacity) {
        if (minCapacity > 0) {
            modCount++;
            ensureCapacityHelper(minCapacity);
        }
    }
    /**
     * 确认是否要扩容，如果指定参数大于当前的实际容量，则直接扩容，以参数为默认大小。
     */
    private void ensureCapacityHelper(int minCapacity) {
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    /**
     默认的最大的数组容量为Integer.MAX_VALUE - 8，不能超过此容量，不然JVM会抛出OutOfMemoryError；
     那8个字节主要是VM保留的字节，用于表示数组的长度，在JVM解析中。
     */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    
    //扩容
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;//当前数组的长度
        //如果指定了增量且大于0，则直接以增量大小扩容，否则增量取当前数组的长度，即直接增加到原来的两倍
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                         capacityIncrement : oldCapacity);
        if (newCapacity - minCapacity < 0)//如果扩容后长度还是小于指定的最小参数minCapacity
            newCapacity = minCapacity;//则以minCapacity参数大小扩容
        if (newCapacity - MAX_ARRAY_SIZE > 0)//主要是为了防止内存溢出
            newCapacity = hugeCapacity(minCapacity);
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
    //防止超出最大的数组范围，如果超出默认取最大值
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }
    /**
     * 设置向量的大小
     （1）如果设置的参数值大于向量的大小，则先扩容，再在后面补齐相应数量的null项
     （2）如果设置的参数值小于向量的大小，则直接将多余的长度丢弃，后面的项也直接设置为null
     */
    public synchronized void setSize(int newSize) {
        modCount++;
        if (newSize > elementCount) {
            ensureCapacityHelper(newSize);
        } else {
            for (int i = newSize ; i < elementCount ; i++) {
                elementData[i] = null;
            }
        }
        elementCount = newSize;//更新长度，后面的null值项直接被回收
    }
    /**
     *返回此向量的当前容量，也就是实际数组的长度
     */
    public synchronized int capacity() {
        return elementData.length;
    }
    /**
     * 返回此向量中的组件数
     */
    public synchronized int size() {
        return elementCount;
    }
    /**
     * 是否为空
     */
    public synchronized boolean isEmpty() {
        return elementCount == 0;
    }
    /**
     * 返回此向量的组件的枚举。返回的 Enumeration 对象将生成此向量中的所有项。
     生成的第一项为索引 0 处的项，然后是索引 1 处的项，依此类推。 
     */
    public Enumeration<E> elements() {
        return new Enumeration<E>() {
            int count = 0;

            public boolean hasMoreElements() {
                return count < elementCount;
            }

            public E nextElement() {
                synchronized (Vector.this) {
                    if (count < elementCount) {
                        return elementData(count++);
                    }
                }
                throw new NoSuchElementException("Vector Enumeration");
            }
        };
    }
    /**
     * 是否包含某个指定元素，此元素可以是null值
     */
    public boolean contains(Object o) {
        return indexOf(o, 0) >= 0;
    }
    /**
     * 返回指定元素第一次出现的索引，如果不包含返回-1
     */
    public int indexOf(Object o) {
        return indexOf(o, 0);
    }
    /**
     * 返回指定元素第一次出现的索引，从指定索引index开始查找，如果不包含返回-1；
     注意一下，null值与普通值也是分开查找的
     */
    public synchronized int indexOf(Object o, int index) {
        if (o == null) {
            for (int i = index ; i < elementCount ; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = index ; i < elementCount ; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }
    /**
     *反向查找指定元素出现的第一次索引位置
     */
    public synchronized int lastIndexOf(Object o) {
        return lastIndexOf(o, elementCount-1);//默认参数是最后一个元素的索引
    }
    /**
     * 反向查找指定元素出现的第一次索引位置，从指定索引index处开始
     */
    public synchronized int lastIndexOf(Object o, int index) {
        if (index >= elementCount)
            throw new IndexOutOfBoundsException(index + " >= "+ elementCount);
        //也是将null值与普通元素分开查询
        if (o == null) {
            for (int i = index; i >= 0; i--)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = index; i >= 0; i--)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }
    /**
     * 返回指定索引处的元素
     */
    public synchronized E elementAt(int index) {
        if (index >= elementCount) {
            throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount);
        }

        return elementData(index);
    }
    /**
     * 返回第一个元素组件
     */
    public synchronized E firstElement() {
        if (elementCount == 0) {
            throw new NoSuchElementException();
        }
        return elementData(0);
    }
    /**
     * 返回最后一个元素组件
     */
    public synchronized E lastElement() {
        if (elementCount == 0) {
            throw new NoSuchElementException();
        }
        return elementData(elementCount - 1);
    }

    /**
     * 在指定的索引位置index处设置指定的新的值obj
     */
    public synchronized void setElementAt(E obj, int index) {
        if (index >= elementCount) {
            throw new ArrayIndexOutOfBoundsException(index + " >= " +
                                                     elementCount);
        }
        elementData[index] = obj;
    }

    /**
     * 删除指定索引位置的组件。
     */
    public synchronized void removeElementAt(int index) {
        modCount++;
        if (index >= elementCount) {
            throw new ArrayIndexOutOfBoundsException(index + " >= " +
                                                     elementCount);
        }
        else if (index < 0) {
            throw new ArrayIndexOutOfBoundsException(index);
        }
        int j = elementCount - index - 1;
        if (j > 0) {//执行数组复制移位覆盖
        /*假设数组元素为1-2-3-4-5，index=2，即从索引下标2移除，则elementCount=5，j=2
        (1)elementData从index+1处开始取j个元素，即4-5
        (2)从elementData指定索引index=2处开始覆盖，即1-2-4-5-5
        (3)将最后的元素设置为null，被GC回收
        */
            System.arraycopy(elementData, index + 1, elementData, index, j);
        }
        elementCount--;//更新长度
        elementData[elementCount] = null; /* to let gc do its work */
    }

    /**
     * 在指定索引处插入一个指定obj组件
     */
    public synchronized void insertElementAt(E obj, int index) {
        modCount++;
        if (index > elementCount) {
            throw new ArrayIndexOutOfBoundsException(index
                                                     + " > " + elementCount);
        }
        //先扩容，增量为1
        ensureCapacityHelper(elementCount + 1);
        //执行数组复制移位覆盖，index处为null值
        System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);
        elementData[index] = obj;//给index处赋值
        elementCount++;//更新长度
    }

    /**
     * 在末尾添加指定的组件
     */
    public synchronized void addElement(E obj) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);//先扩容，增量为1
        elementData[elementCount++] = obj;//直接在末尾添加一个元素，并且赋值
    }

    /**
     * 删除指定值的组件
     */
    public synchronized boolean removeElement(Object obj) {
        modCount++;
        int i = indexOf(obj);//先找到指定值的索引位置
        if (i >= 0) {//如果存在，则直接调用删除指定索引位置方法删除
            removeElementAt(i);
            return true;
        }
        return false;
    }

    /**
     * 移除所有的组件
     */
    public synchronized void removeAllElements() {
        modCount++;
        // Let gc do its work，也就是将所有的元素都设置为null，之后由GC回收掉
        for (int i = 0; i < elementCount; i++)
            elementData[i] = null;

        elementCount = 0;
    }

    /**
     * 返回向量的一个副本。副本中将包含一个对内部数据数组副本的引用，
     而非对此 Vector 对象的原始内部数据数组的引用。
     */
    public synchronized Object clone() {
        try {
            @SuppressWarnings("unchecked")
                Vector<E> v = (Vector<E>) super.clone();//产生一个新的vector对象
                //内部实际上是复制产生一个新的数组，将新的对象指向这个数组
            v.elementData = Arrays.copyOf(elementData, elementCount);
            v.modCount = 0;
            return v;
        } catch (CloneNotSupportedException e) {
            // this shouldn't happen, since we are Cloneable
            throw new InternalError();
        }
    }

    /**
     * 返回一个数组，包含顺序存放的所有元素
     */
    public synchronized Object[] toArray() {
        return Arrays.copyOf(elementData, elementCount);
    }

    /**
     * 运行时指定返回的数组类型
     1、如果给定的数组长度小于向量中元素的个数，则返回一个复制的数组，类型为指定的类型，数组后面用null值填充；
     2、如果给定的数组长度大于向量中元素的个数，则直接全部复制到数组中；
     */
    @SuppressWarnings("unchecked")
    public synchronized <T> T[] toArray(T[] a) {
        if (a.length < elementCount)//1
            return (T[]) Arrays.copyOf(elementData, elementCount, a.getClass());

        System.arraycopy(elementData, 0, a, 0, elementCount);//2

        if (a.length > elementCount)//填充null值
            a[elementCount] = null;

        return a;
    }

    // 返回指定位置的组件，其实与get(int)方法功能完全相同
    @SuppressWarnings("unchecked")
    E elementData(int index) {
        return (E) elementData[index];
    }

    /**
     * 返回指定位置的元素
     */
    public synchronized E get(int index) {
        if (index >= elementCount)
            throw new ArrayIndexOutOfBoundsException(index);

        return elementData(index);
    }

    /**
     * 给指定索引index处设置指定值element
     */
    public synchronized E set(int index, E element) {
        if (index >= elementCount)
            throw new ArrayIndexOutOfBoundsException(index);

        E oldValue = elementData(index);
        elementData[index] = element;//覆盖旧的值
        return oldValue;//返回旧的值
    }

    /**
     * 在向量尾部添加一个指定元素e
     */
    public synchronized boolean add(E e) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);//先扩容，增量为1
        elementData[elementCount++] = e;//赋值
        return true;
    }

    /**
     * 从向量头部开始移除匹配到的第一个指定元素o
     */
    public boolean remove(Object o) {
        return removeElement(o);
    }

    /**
     * 在指定的索引位置index处添加指定新的值element
     */
    public void add(int index, E element) {
        insertElementAt(element, index);
    }

    /**
     * 移除指定索引index处的元素，并且返回此元素
     */
    public synchronized E remove(int index) {
        modCount++;
        if (index >= elementCount)
            throw new ArrayIndexOutOfBoundsException(index);
        E oldValue = elementData(index);

        int numMoved = elementCount - index - 1;
        if (numMoved > 0)
            //实际上就是将index的后面元素集体往前面移动一个位置覆盖
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--elementCount] = null; //再将最后一个元素值null回收掉

        return oldValue;
    }

    /**
     * 移除向量中所有的元素
     */
    public void clear() {
        removeAllElements();
    }

    /**
     * 此向量是否包含指定组件的所有元素
     */
    public synchronized boolean containsAll(Collection<?> c) {
        return super.containsAll(c);
    }

    /**
     * 将指定容器中的元素添加到此向量的尾部
     */
    public synchronized boolean addAll(Collection<? extends E> c) {
        modCount++;
        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacityHelper(elementCount + numNew);//以参数中的元素长度为增量扩容
        System.arraycopy(a, 0, elementData, elementCount, numNew);//产生新的数组
        elementCount += numNew;//更新向量中元素的个数
        return numNew != 0;
    }

    /**
     *移除向量中所有的元素
     */
    public synchronized boolean removeAll(Collection<?> c) {
        return super.removeAll(c);
    }

    /**
     *只保留指定容器中包含的元素
     */
    public synchronized boolean retainAll(Collection<?> c) {
        return super.retainAll(c);
    }

    /**
     *从指定的索引index处，将指定容器c中的所有元素插入到此向量中
     */
    public synchronized boolean addAll(int index, Collection<? extends E> c) {
        modCount++;
        if (index < 0 || index > elementCount)
            throw new ArrayIndexOutOfBoundsException(index);

        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacityHelper(elementCount + numNew);//先扩容，增量为指定容器中元素的长度

        int numMoved = elementCount - index;
        if (numMoved > 0)//如果插入位置没有超过向量元素索引下标
            System.arraycopy(elementData, index, elementData, index + numNew,
                             numMoved);
        //如果插入位置刚好在尾部
        System.arraycopy(a, 0, elementData, index, numNew);
        elementCount += numNew;
        return numNew != 0;
    }

    /**
     * 比较指定对象与此向量的相等性。当且仅当指定的对象也是一个 List、两个 List 大小相同，
     并且其中所有对应的元素对都相等 时才返回 true。（如果 (e1==null ? e2==null : e1.equals(e2))，
     则两个元素 e1 和 e2 相等）。
     换句话说，如果两个 List 包含相同顺序的相同元素，则这两个 List 就定义为相等。
     */
    public synchronized boolean equals(Object o) {
        return super.equals(o);
    }

    /**
     * 返回此向量的hash值
     */
    public synchronized int hashCode() {
        return super.hashCode();
    }

    /**
     * 返回此向量的字符串表示形式，其中包含每个元素的String表示形式
     */
    public synchronized String toString() {
        return super.toString();
    }

    /**
     *返回此 List 的部分视图，元素范围为从 fromIndex（包括）到 toIndex（不包括）。
     */
    public synchronized List<E> subList(int fromIndex, int toIndex) {
        return Collections.synchronizedList(super.subList(fromIndex, toIndex),
                                            this);
    }

    /**
     * 移除向量中指定参数范围内的所有元素，元素范围为从 fromIndex（包括）到 toIndex（不包括）
     */
    protected synchronized void removeRange(int fromIndex, int toIndex) {
        modCount++;
        int numMoved = elementCount - toIndex;//如果numMoved小于0，会直接抛出异常
        /**还是实际例子说明：向量中初始元素为 1，2，3，4，5，6 elementCount=6，
        参数假设fromIndex=2，toIndex=4 则numMoved = 2；
        (1)从toIndex=4(包含)开始取长度为numMoved = 2数组，即5,6
        (2)从fromIndex=2(包含)开始用(1)中的数组覆盖，即1,2,5,6,5,6
        (3)将最后的5，6设置为null，回收，实现了范围删除
        */
        System.arraycopy(elementData, toIndex, elementData, fromIndex,
                         numMoved);

        // Let gc do its work
        int newElementCount = elementCount - (toIndex-fromIndex);
        while (elementCount != newElementCount)
            elementData[--elementCount] = null;//将最后的元素设置为null，被GC回收
    }

    /**
     * 序列化写入函数
     */
    private void writeObject(java.io.ObjectOutputStream s)
            throws java.io.IOException {
        final java.io.ObjectOutputStream.PutField fields = s.putFields();
        final Object[] data;
        synchronized (this) {
            fields.put("capacityIncrement", capacityIncrement);
            fields.put("elementCount", elementCount);
            data = elementData.clone();
        }
        fields.put("elementData", data);
        s.writeFields();
    }

    /**
     * 迭代
     */
    public synchronized ListIterator<E> listIterator(int index) {
        if (index < 0 || index > elementCount)
            throw new IndexOutOfBoundsException("Index: "+index);
        return new ListItr(index);
    }

    /**
     * Returns a list iterator over the elements in this list (in proper
     * sequence).
     *
     * <p>The returned list iterator is <a href="#fail-fast"><i>fail-fast</i></a>.
     *
     * @see #listIterator(int)
     */
    public synchronized ListIterator<E> listIterator() {
        return new ListItr(0);
    }

    public synchronized Iterator<E> iterator() {
        return new Itr();
    }

    private class Itr implements Iterator<E> {
        int cursor;       // 下一个要迭代元素的索引
        int lastRet = -1; // 上一个元素的索引位置，lastRet永远比cursor小1，cursor位于开始位置0时，lastRet初始化为-1
        int expectedModCount = modCount;

        public boolean hasNext() {
            // 向量中后序是否还有元素可以迭代
            return cursor != elementCount;
        }

        public E next() {//同步的迭代下一个元素
            synchronized (Vector.this) {
                checkForComodification();
                int i = cursor;
                if (i >= elementCount)
                    throw new NoSuchElementException();
                cursor = i + 1;
                return elementData(lastRet = i);//每次迭代后更新前一个索引
            }
        }

        public void remove() {//移除前一个元素
            if (lastRet == -1)
                throw new IllegalStateException();
            synchronized (Vector.this) {
                checkForComodification();
                Vector.this.remove(lastRet);
                expectedModCount = modCount;
            }
            cursor = lastRet;
            lastRet = -1;
        }

        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }

    /**
     * An optimized version of AbstractList.ListItr
     */
    final class ListItr extends Itr implements ListIterator<E> {
        ListItr(int index) {
            super();
            cursor = index;//int cursor 下一个要迭代元素的索引
        }

        public boolean hasPrevious() {//当前迭代的元素前面是否有元素，即是否为第一个元素
            return cursor != 0;
        }

        public int nextIndex() {//下一个要迭代元素的索引
            return cursor;
        }

        public int previousIndex() {//返回当前迭代元素的前一个元素的索引
            return cursor - 1;
        }

        public E previous() {//返回当前迭代元素的前一个元素
            synchronized (Vector.this) {
                checkForComodification();
                int i = cursor - 1;
                if (i < 0)
                    throw new NoSuchElementException();
                cursor = i;
                return elementData(lastRet = i);
            }
        }

        public void set(E e) {//在当前迭代的前面索引处设置指定元素值
            if (lastRet == -1)
                throw new IllegalStateException();
            synchronized (Vector.this) {
                checkForComodification();
                Vector.this.set(lastRet, e);//实际上内部调用的是设置元素，在指定位置
            }
        }

        public void add(E e) {//添加当前迭代的位置插入指定元素
            int i = cursor;
            synchronized (Vector.this) {
                checkForComodification();
                Vector.this.add(i, e);//实际上内部调用的是插入元素，在i位置
                expectedModCount = modCount;
            }
            cursor = i + 1;
            lastRet = -1;
        }
    }
}

总结以下：

1、无参构造函数，默认初始化容量为10，标准容量增量为0；

2、执行扩容时，如果指定了增量且大于0，则直接以增量大小扩容，否则增量取当前数组的长度，即直接增加到原来的两倍；

3、默认的最大的数组容量为Integer.MAX_VALUE - 8，不能超过此容量，不然JVM会抛出OutOfMemoryError；那8个字节主要是VM保留的字节，用于表示数组的长度，在JVM解析中。

4、设置向量的大小时：

（1）如果设置的参数值大于向量的大小，则先扩容，再在后面补齐相应数量的null项；
（2）如果设置的参数值小于向量的大小，则直接将多余的长度丢弃，后面的项也直接设置为null。

5、在执行查找时，null值元素与非空元素也是分开遍历查找；