Vector源码分析

基于JDK1.8源码进行分析的

Vector

其实，Vector的内部实现和ArrayList的内部实现基本一致，内部都是借助于数组来实现的。

继承结构

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

Vector继承了AbstractList抽象类并实现了List、RandomAccess、Cloneable、Serializable接口，ArrayList的结构Vector一样。

RandomAccess接口是在源码中的注释如下：

Marker interface used by List implementations to indicate that they support fast (generally constant time) random access；

属性

//数组，用来存放元素的
protected Object[] elementData;
//记录数组中已经保存了的数据的个数
protected int elementCount;
//自动扩容的大小，即当数组满了之后，就添加capacityIncrement个空间装载元素，如果
//capacityIncrement<=0,则扩容时就扩容到目前Vector容量的两倍
protected int 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);
}

public Vector() {
    this(10);
}

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

initialCapacity:指定的初始容量，默认值为10。
capacityIncrement：指定的每次的扩容大小，默认值是0，capacityIncrement=0代表的意思是，当数组装满之后，扩容为目前数组大小的两倍。当我们使用使用Vector时，如果我们知道Vector存储的元素大概会达到多少，就指定Vector的容量，当存储数量比较大时，就不要使用 Vector v= new Vector()来创建Vector实例对象，这个实际上就是创建了长度为10 ，增长因子为0 的Object 数组。当存储数量比较大时，会添加扩容后复制原来的数组中的元素到新数组中带来的开销。

最下面一个构造方法内部实现时，直接将Collection转化为了数组返回。

方法

add(E e)

public synchronized boolean add(E e) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }

添加元素的方法实现比较简单：直接在数组的后一个位置添加即可，不过在添加元素之前需要检查数组中是否已满，如果已满，则扩容。用到的方法ensureCapacityHelper，源码如下：

private void ensureCapacityHelper(int minCapacity) {
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

如果已满，则调用grow函数进行扩容。扩容之后进行数据的拷贝即可。在grow函数中如果扩容后的数据进行一些判断，例如检测是否溢出呀，检测是否达到了MAX_ARRAY_SIZE呀，分别对这些进行了一些处理。

    //当数组已满，则调用grow函数来对数组进行扩容
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        //扩容的大小由capacityIncrement决定，如果capacityIncrement<=0,则扩容到目前数组的两倍
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                         capacityIncrement : oldCapacity);
        //检查是否newCapacity溢出了
        if (newCapacity - minCapacity < 0)
            newCapacity = 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;
    }

add(int index, E element) 

函数的功能：在指定位置添加元素。方法实现的思想也比较简单：首先检查是否需要扩容，如果需要，则进行扩容；接着将数组从索引index开始的元素全部向后移动一位。最后将元素保存在数组的index位置即可。

public void add(int index, E element) {
        insertElementAt(element, index);
    }

其中insertElementAt方法源码如下，可见添加了synchronized关键字 

    public synchronized void insertElementAt(E obj, int index) {
        modCount++;
        //有效性检查
        if (index > elementCount) {
            throw new ArrayIndexOutOfBoundsException(index
                                                     + " > " + elementCount);
        }
        //检查是否需要扩容，若需要，则进行扩容
        ensureCapacityHelper(elementCount + 1);
        //拷贝
        System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);
        elementData[index] = obj;
        elementCount++;
    } 

get(int index)

由于Vector是借助于数组来实现的，因此get方法的内部实现也就是取出位置为index的元素。

    public synchronized E get(int index) {
        if (index >= elementCount)
            throw new ArrayIndexOutOfBoundsException(index);

        return elementData(index);
    }

可以看到get、add方法都是用了synchronized关键字进行修饰，说明他们是线程安全的，在多线程并发时，不需要我们进行额外的同步。而ArrayList是没有进行同步的。这也是Vector和ArrayList的一个区别。

set(int index, E element)

Vector底层是基于数组来实现的。所以set实现如下：

    public synchronized E set(int index, E element) {
        if (index >= elementCount)
            throw new ArrayIndexOutOfBoundsException(index);

        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;
    }

remove(Object o)

去除掉元素o。先找到该元素在数组中的位置index；然后移除索引位置为index的元素即可。

    public boolean remove(Object o) {
        return removeElement(o);
    }   

    public synchronized boolean removeElement(Object obj) {
        modCount++;
        int i = indexOf(obj);
        if (i >= 0) {
            removeElementAt(i);
            return true;
        }
        return false;
    }
    public int indexOf(Object o) {
        return indexOf(o, 0);
    }
    /*
        函数的功能：找到元素o在数组在index位置后出现的位置
    */
    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 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) {
            System.arraycopy(elementData, index + 1, elementData, index, j);
        }
        elementCount--;
        elementData[elementCount] = null; /* to let gc do its work */
    }

remove(int index)

去除掉Vector索引为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)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--elementCount] = null; // Let gc do its work

        return oldValue;
    }

elements方法

创建了一个枚举类型，里面实现还是通过元素是否存在，通过下标遍历数组。

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

Vector可见，与ArrayList对比来看，后者是线程不安全的，在多线程并发时，需要我们进行额外的同步。

其他代码就不一一粘贴在这里了。大部分代码的实现思路与ArrayList类似。

当然如果想得到一个线程安全的ArrayList，可以通过以下方案。

List<String> list = new ArrayList<String>();
List<String> syncList = Collections.synchronizedList(list);

当然也可以采用并发包下的CopyOnWriteArrayList实现。