java.util.Vector源码解析

1.java集合框架图

2.所属包

package java.util;

3.继承与实现关系

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

4.准备知识

Vector集合实际上是实现了动态数组的方式，是可以随着向量元素的增加可以动态增长。实际上就是一种动态顺序表的应用。

5.属性

   /**
     * Object类型的数组，用来存储实际数据
     */
    protected Object[] elementData;

    /**
     * 代表向量中元素的个数
     */
    protected int elementCount;

    /**
     * 向量的增长因数
     * 当向量的容量大于其容量时，向量的容量自动递增的量。
     * 如果容量增量小于或等于零，则每次需要增长时，向量的容量增加一倍。
     */
    protected int capacityIncrement;

6.构造方法

  /**  构造方法1
     * 输入参数为初始化容量和增量参数的构造方法
     */
    public Vector(int initialCapacity, int capacityIncrement) {
        super();
	//如果向量初始化容量小于0,那么就报非法参数异常的错误。
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
	//将初始化容量的长度作为Object数组实际长度
        this.elementData = new Object[initialCapacity];
	//初始化增量参数
        this.capacityIncrement = capacityIncrement;
    }

   /** 构造方法2
     * 使用指定的初始容量和等于零的容量增量构造一个空向量
     */
    public Vector(int initialCapacity) {
        this(initialCapacity, 0);
    }

   /** 构造方法3
     * 构造一个初始化容量为10，增量为0的向量
     */
    public Vector() {
        this(10);
    }

   /** 构造方法4
     * 构造一个包含指定集合中的元素的向量，这些元素按其集合的迭代器返回元素的顺序排列。
     */
    public Vector(Collection<? extends E> c) {
	//将集合Collection转化为Object数组elementData。如果c为空，那么就会报空指针异常
        elementData = c.toArray();
        elementCount = elementData.length;
        //将c中的元素拷贝到elementData中
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
    }

7.方法

ensureCapacity方法：扩充容量

   /**
         * 增加此向量的容量（如有必要），以确保其至少能够保存最小容量参数指定的组件数。
	 * 如果当前数组的容量小于minCapacity，那么就增加容量，增加数组长度
	 * 新数组的长度等于原数组的长度加上增量capacityIncrement。
	 * 如果增加capacityIncrement小于等于0，那么就自动扩增为原来二倍。
	 * 如果扩增为原来的二倍还是比minCapacity小，那么就将minCapacity作为Object数组的长度。
     */
    public synchronized void ensureCapacity(int minCapacity) {
        if (minCapacity > 0) {
            modCount++;
            ensureCapacityHelper(minCapacity);
        }
    }

 private void ensureCapacityHelper(int minCapacity) {
        //minCapacity为实际向量中的元素需要的容量，如果minCapacity大于当前数组长度，那么就进行扩容
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    private void grow(int minCapacity) {
        //oldCapacity旧容量是Object数组的长度
        int oldCapacity = elementData.length;
	//如果增量capacityIncrement大于0，那么新容量为旧容量加上增量，否则为旧容量的2倍
        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);
    }

    private static int hugeCapacity(int minCapacity) {
	//如果实际需要的容量小于0就抛出异常
        if (minCapacity < 0) 
            throw new OutOfMemoryError();
	//实际容量如果比最大容量还大，那么实际容量为Integer.MAX_VALUE，否则为Integer.MAX_VALUE - 8
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

add方法

/**
     * 采用同步的方式往向量中添加元素e
     */
    public synchronized boolean add(E e) {
        modCount++;
		//由于添加元素需要动态的扩容，所以调用ensureCapacityHelper方法，长度要增长1
        ensureCapacityHelper(elementCount + 1);
		//这步采用顺序表添加元素的模板代码，赋值长度加1
        elementData[elementCount++] = e;
        return true;
    }

---------------------------该源码为jdk1.7版本的