集合框架之Vector源码分析（JDK1.8）

 Vector extends AbstractList implements List, RandomAccess, Cloneable, java.io.Serializable

从上述代码可以看出来Vector集合继承了AbstractList抽象类实现了List接口，所以它兼具AbstractList和List抽象方法，当我们new一个无参数的Vector对象时，构造函数首先调用带参的构造函数，并赋值一个初始数组长度10，除非指定初始长度。这一点和ArrayList差别是巨大的，创建无参数的ArrayList对象并没有初始化一个长度为10的数组（JDK1.8之后），而是在第一次add值得时候才初始化，HashMap也是put值得时候初始化数组长度，关于HashMap和ArrayList这些以后的博文里会提到，这里不是重点。

Vector vector=new Vector<>();

public Vector() {
    this(10);
}

public Vector(int initialCapacity) {
    this(initialCapacity, 0);
}

public Vector(int initialCapacity, int capacityIncrement) {
    super();
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    this.elementData = new Object[initialCapacity];
    this.capacityIncrement = capacityIncrement;
}

以上三段引用是一个调用顺序，由此可以证明Vector在创建对象的时候初始化了一个默认长度为10的数组；

接下来看看添加元素的方法，之所以说Vector是线程安全的关键点都在 synchronized 上，它保证了每次只能一个线程访问该方法，所以线程安全。

public synchronized boolean add(E e) {
    modCount++;                              //操作次数
    ensureCapacityHelper(elementCount + 1);  //确保元素+1之后数组的长度足够使用
    elementData[elementCount++] = e;         //把元素添加到上一个元素之后
    return true;
}

ensureCapacityHelper(elementCount + 1);这个段代码是用来确保数组长度足够使用的，如果数组长度不够用怎么办？

private void ensureCapacityHelper(int minCapacity) {  // minCapacity添加最后一个元素后，元素的总数
    // overflow-conscious code
    if (minCapacity - elementData.length > 0)         // elementData.length数组的长度
        grow(minCapacity);                            // 如果实际的元素个数超过了数组的最大长度，则执行这一行扩容
}                                                     // 并把元素的个数传进去

扩容扩多少合适呢（一般情况是原来数组的2倍，如果数组长度接近于Integer的最大值另当别论）？接着往下看代码

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;                 // 数组长度
                                                          // 初始化数组的时候已知 capacityIncrement = 0
                                                          // 可知newCapacity = oldCapacity + oldCapacity 
    int newCapacity = oldCapacity + ((capacityIncrement > 0) ? capacityIncrement : oldCapacity);
    if (newCapacity - minCapacity < 0)                    // 此时newCapacity 等于原来数组的2倍
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)                 // MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8
        newCapacity = hugeCapacity(minCapacity);          // 当扩容后的长度非常大的时候
    elementData = Arrays.copyOf(elementData, newCapacity);// 把原来的元素复制到新的数组一份，
                                                          // 并把原来的数组指向新数组
}

该扩容不是无限的，过大则会产生内存溢出，如果扩容后的值大于Integer的最大值则使用最大值

private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
}

如果创建了一个指定初始数组长度和扩容增量，则以后的扩容会每次增加 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;
}

至于删除和获取集合的长度，并没有太难的知识点，读懂以上的初始化数组和添加方法，其他的就一目了然了。

待续

---