Vector的扩容机制原理及源码分析

1.初始化Vector无参构造器

1.1 使用无参构造器创建Vector对象

Vector vector = new Vector();

    源码分析：调用无参构造器，默认为Object数组赋予长度为10。

  public Vector() {
        this(10);
    }

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

//initialCapacity = 10；capacityIncrement=0
public Vector(int initialCapacity, int capacityIncrement) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        //将initialCapacity = 10赋值给elementData数组的长度
        this.elementData = new Object[initialCapacity];
        this.capacityIncrement = capacityIncrement;
    }

1.2 调用add(E e）方法添加数据

源码分析：首次添加数据时，长度小于elementData数组的长度，不进行扩容，如果数据个数大于elementData数组长度，则进行扩容，扩容为elementData数组长度的2倍。

  for (int i = 0; i <10 ; i++) {
            vector.add(i);
        }


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

 private void ensureCapacityHelper(int minCapacity) {
        // overflow-conscious code
        //此时minCapacity大小<=10 不进行扩容，否则进行扩容
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }


  private void grow(int minCapacity) {
        // elementData.length = 10
        int oldCapacity = elementData.length;
        //newCapacity = 10；capacityIncrement =0
        //三位运算符  此时newCapacity  = oldCapacity  + oldCapacity 值，即为原先的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);
    }

结论：调用无参构造器，默认为elementData数组赋予长度为10，需再次扩容时，扩为elementData数组长度的2倍。

2.初始化Vector有参构造器

2.1 使用有参构造器创建Vector对象

        源码分析：使用有参构造器创建Vector对象，创建了一个固定大小的elementData数组。

 Vector vector2 = new Vector(8);

//initialCapacity = 8
 public Vector(int initialCapacity) {
        this(initialCapacity, 0);
    }
//initialCapacity = 8 ；capacityIncrement = 0
  public Vector(int initialCapacity, int capacityIncrement) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        //将初始化的大小赋值给elementData数组的长度
        this.elementData = new Object[initialCapacity];
        this.capacityIncrement = capacityIncrement;
    }

1.2 调用add(E e）方法添加数据

源码分析：添加数据时，数据的个数小于elementData数组的长度，不进行扩容，如果数据个数大于elementData数组长度，则进行扩容，扩容为elementData数组长度的2倍。

for (int i = 0; i < 8; i++) {
            vector2.add(i);
        }
        //进行扩容
        vector2.add(8);

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

结论：调用有参构造器，创建了一个固定大小的elementData数组，需再次扩容时，扩为elementData数组长度的2倍。

3.总结

        1）调用无参构造器，默认为elementData数组赋予长度为10，需再次扩容时，扩为elementData数组长度的2倍。

        2）调用有参构造器，创建了一个固定大小的elementData数组，需再次扩容时，扩为elementData数组长度的2倍。