Java之Vector源码简单分析

• 前言
• 一、初始化
• 二、添加元素
• 总结
• 参考文献

通过Vector源码的分析，来简单了解Vector初始化和扩容机制。
ArrayList源码简单分析，可以对比着学习。

Vector跟ArrayList一样实现了List接口，但是它是线程同步的，方法上加了synchronized同步锁，所以线程安全效率低。

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

当执行List v = new Vector<>();，会立即初始化一个大小为10的底层数组，不会向ArrayList一样做一个懒加载，估计是ArrayList用到的场景太多。

protected transient int modCount = 0;
protected Object[] elementData;
protected int elementCount;
public synchronized boolean add(E e) {
        modCount++;
        add(e, elementData, elementCount);
        return true;
    }
private void add(E e, Object[] elementData, int s) {
        if (s == elementData.length)
            elementData = grow();
        elementData[s] = e;
        elementCount = s + 1;
    }
private Object[] grow() {
        return grow(elementCount + 1);
    }
private Object[] grow(int minCapacity) {
        return elementData = Arrays.copyOf(elementData,
                                           newCapacity(minCapacity));
    }
protected int capacityIncrement;
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
private int newCapacity(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                         capacityIncrement : oldCapacity);
        if (newCapacity - minCapacity <= 0) {
            if (minCapacity < 0) // overflow
                throw new OutOfMemoryError();
            return minCapacity;
        }
        return (newCapacity - MAX_ARRAY_SIZE <= 0)
            ? newCapacity
            : hugeCapacity(minCapacity);
    }
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）modCount++是记录了修改次数，也不知道有什么用，modCount是来自AbstractList抽象类的静态属性，Vector、ArrayList都继承了这个类。
2）扩容机制，如果要在第size-1后面加一个元素，需要判断底层数组的长度为size，那么就开始实现扩容机制，来到newCapability()函数进行扩容，而跟ArrayList扩容的区别在于int newCapacity = oldCapacity + ((capacityIncrement > 0) ? capacityIncrement : oldCapacity);每次扩容自原来的两倍，而上限的确定就是一样的，当扩容到大于默认长度，就需要看原来的长度，添加一个元素即length+1是否大于默认最大长度MAX_ARRAY_SIZE，是就扩容至最大Integer.MAX_VALUE，否则就用最大默认长度作为扩容的大小，而不是用原来的二倍作为扩容大小。

1）初始化，不会懒加载一个空数组，而是之间初始化长度为10的数组。
2）添加元素，主要是扩容机制，不同于ArrayList的是先扩容原来的一倍，然后再判断是否超过MAX_ARRAY_SIZE来做进一步的真实扩容。

[1] [JDK 1.12 源码]