Vector扩容机制及源码分析

扩容机制

Vector内维护了一个Object数组

 protected Object[] elementData;

构造器

• 无参构造，初始化的默认长度是10，每次数组扩容* 2

• 有参构造(int)，指定初始容量，每次都是两倍扩容(不指定capacityIncrement，默认为0)

• 有参构造(int ,int)，每次扩容 + capacityIncrement(第二个参数指定capacityIncrement)，即指定了每次的扩容大小

 // 无参构造
 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;
 }
 ​
 // 拷贝构造
 public Vector(Collection<? extends E> c) {
     Object[] a = c.toArray();
     elementCount = a.length;
     if (c.getClass() == ArrayList.class) {
         elementData = a;
     } else {
         elementData = Arrays.copyOf(a, elementCount, Object[].class);
     }
 }

add方法源码分析

public synchronized boolean add(E e) {
    modCount++;
    // 判断是否需要扩容
    ensureCapacityHelper(elementCount + 1);
    elementData[elementCount++] = e;
    return true;
}

private void ensureCapacityHelper(int minCapacity) {
    // overflow-conscious code
    // 数组长度小于所需要的最小长度
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

// 扩容
private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    // 如果未指定capacityIncrement, 则每次扩容到2倍，
    // 如果指定了capacityIncrement, 则每次 + capacityIncrement
    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);
}