扩容机制
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);
}