集合 Vector

线程安全的ArrayList结构，初始容量为10

Vector<Integer> vector = new Vector<Integer>();

构造方法 ：

第一次构造时候：调用无参构造方法： Vector vector = new Vector();

//调用 无参构造实际上是在间接的调用有参构造，只是两个参数都是默认设置的,this这个方法帮我们隐样的传递了
public Vector() {
   this(10);            // 调用this 传入了一个参数1，作用是初始化容量为10；
}

public Vector(int initialCapacity) {
   this(initialCapacity, 0);          //10作为initialCapacity传入：这是vector类的一个属性
}

public Vector(int initialCapacity, int capacityIncrement) {  //传入10,0，产生一个10容量的obj类型的数组
   super();
   if (initialCapacity < 0)
       throw new IllegalArgumentException("Illegal Capacity: "+
                                          initialCapacity);
   this.elementData = new Object[initialCapacity];   //如果 这个构方法被重写，10是可调的
   this.capacityIncrement = capacityIncrement;
}
//这里直接使用有参构造方法，跳过第一步无参构造后传参的步骤，默认容量随即被修改
Vector<Integer> vector2 = new Vector<Integer>(22,0);
		
		System.out.println(vector2.capacity());

添加元素：

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);
//2倍自增扩容
   if (newCapacity - minCapacity < 0)
       newCapacity = minCapacity;
   if (newCapacity - MAX_ARRAY_SIZE > 0)
       newCapacity = hugeCapacity(minCapacity);
//扩容方式为数组的复制
   elementData = Arrays.copyOf(elementData, newCapacity);
}

//指定下标添加元素
public void add(int index, E element) {
   insertElementAt(element, index);
}
public synchronized void insertElementAt(E obj, int index) {
   modCount++;
//判断下标是否合法（是否超出有效范围）
   if (index > elementCount) {
       throw new ArrayIndexOutOfBoundsException(index
                                                    + " > " + elementCount);
   }
//
   ensureCapacityHelper(elementCount + 1);
//元素个数增速没有容量增速快，容量扩容频率没有添加元素频率高，所以要写if方法判断是否扩容；

   System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);
   elementData[index] = obj;   //目标下标的添加元素
   elementCount++;  //自增
}
private void ensureCapacityHelper(int minCapacity) {
   // overflow-conscious code
   if (minCapacity - elementData.length > 0)//目标容量比当前长度大
       grow(minCapacity);//扩容
}

标签：index,Vector,int,elementData,initialCapacity,minCapacity,集合
来源： https://www.cnblogs.com/msslearning/p/14870755.html