java源码分析---Vector

Vector源码解析

1. 体系结构

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

Vector继承了AbstractList，并实现了List、RandomAccess、Cloneable和Serializable接口，与ArrayList结构相同
2. 属性

    protected Object[] elementData;
    protected int elementCount;
    protected int capacityIncrement;

elementData:数组，用来存放元素的
elementCount:记录数组中已经保存了的数据的个数
capacityIncrement：自动扩容的大小，即当数组满了之后，就添加capacityIncrement个空间装载元素，如果capacityIncrement<=0,则扩容时就扩容到目前Vector容量的两倍
3. 构造函数
Vector有四个构造函数，源码如下：

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

我们看到在默认情况下Vector会创建一个容量为10的Object数组，所以当我们使用使用Vector时，如果我们知道Vector存储的元素大概会达到多少，就指定Vector的容量，当存储数量比较大时，就不要使用 Vector v= new Vector()来创建Vector实例对象，这个实际上就是创建了长度为10 ，增长因子为0 的Object 数组。当存储数量比较大时，会添加扩容后复制原来的数组中的元素到新数组中带来的开销。
Vector类中还有如下一个用Collection初始化Vector对象实例的构造函数，内部实现时直接将Collection转化为了数组返回。
4. 常用方法
4.1 add(E e)

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

add方法的思想是首先判断下数组是否需要扩容，不需要的话直接将元素添加到数组末尾，否则先扩容后再添加元素，其中使用了ensureCapacityHelper这个方法，源码如下：

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

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

private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                         capacityIncrement : oldCapacity);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

4.2 void add(int index, E element)

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

此方法直接使用了insertElementAt方法来实现，源码如下：

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

方法思想也比较简单，首先判断插入索引的位置是否合法，然后判断数组是否需要扩容，然后进行元素拷贝，最后将元素插入到数组对应的索引位置上
4.3 synchronized E get(int index)

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

        return elementData(index);
    }

首先看到此方法是一个同步方法，说明他们是线程安全的，在多线程并发时，不需要我们进行额外的同步。而ArrayList是没有进行同步的。这也是Vector和ArrayList的一个区别。此方法比较简单，因为Vector内部是数组实现的，所以在index合法的情况下直接取出数组元素即可
4.4 synchronized E set(int index, E 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;
    }

此方法也是一个同步方法，因此也是线程安全的。方法也很简单，就不过多解析了
4.5 remove(Object o)

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

此方法使用了removeElement来实现的，我们看下其源码：

public synchronized boolean removeElement(Object obj) {
        modCount++;
        int i = indexOf(obj);
        if (i >= 0) {
            removeElementAt(i);
            return true;
        }
        return false;
    }

思想比较简单，首先找到元素的位置，然后使用removeElementAt函数来移除元素，再继续跟踪下次方法；

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 */
    }

可以看到此方法也是一个同步方法，也是线程安全的，方法的思想也是比较简单的。
4.6 synchronized E remove(int 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;
    }

此方法也是同步方法，线程安全的
4.7 Enumeration 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");
            }
        };
    }

方法中创建了一个枚举类型，里面实现还是通过元素是否存在，通过下标遍历数组，这里就过多的进行介绍。
4.8 其他方法

    public boolean contains(Object o) {
        return indexOf(o, 0) >= 0;
    }
    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 E elementAt(int index) {
        if (index >= elementCount) {
            throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount);
        }

        return elementData(index);
    }

5. 总结
Vector里面还有很多方法，我们只需要知道Vector里面是基于数组来实现的，然后用正常的思维来思考常见的方法的实现也没有任何问题的，这里就不做过多的介绍了。需要注意的是：Vector是线程安全的，因此，在多线程并发中是不需要使用额外同步的，而ArrayList实现基本与Vector一样，但是区别是：ArrayList是线程不安全的，在多线程并发时，需要我们进行额外的同步