下文带/**/为源码注释//为个人注释。源代码使用这个颜色
/*存储矢量分量的数组缓冲区。向量的容量是这个数组缓冲区的长度，并且至少足够大来包含向量的所有元素。*/
//存放集合元素的数组
protected Object[] elementData;
/*当矢量的大小大于其容量时，其容量自动增加的数量。如果容量增量小于或等于零，则每次需要增长时，向量的容量就增加一倍。*/
//应该是集合扩容时用到的，它的作用还有待考
protected int capacityIncrement;
//集合的长度，默认是0
protected int elementCount;
/*构造一个空向量，以便其内部数据数组的大小为10，其标准容量增量为零。*/
public Vector() {
this(10);
}
/*构造一个具有指定初始容量且容量增量为零的空向量。*/
public Vector(int initialCapacity) {
this(initialCapacity, 0);
}
/*构造一个具有指定初始容量和容量增量的空向量。*/
public Vector(int initialCapacity, int capacityIncrement) {
super();
//如果初始容量小于0报错
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
//创建一个容量10的数组
this.elementData = new Object[initialCapacity];
//增量为0
this.capacityIncrement = capacityIncrement;
}
/*将指定的元素追加到此向量的末尾。*/
//加锁了
public synchronized boolean add(E e) {
modCount++;
//第一次添加传入参数为elementCount=0 (0+1)
//第二次添加传入参数为elementCount=1 (1+1)
//第三次添加传入参数为elementCount=2 (2+1)
//第四次添加传入参数为elementCount=3 (3+1)
//第五次添加传入参数为elementCount=4 (4+1)
//第六次添加传入参数为elementCount=5 (5+1)
//第七次添加传入参数为elementCount=6 (6+1)
//第八次添加传入参数为elementCount=7 (7+1)
//第九次添加传入参数为elementCount=8 (8+1)
//第十次添加传入参数为elementCount=9 (9+1)
//第十一次添加传入参数为elementCount=10 (10+1)
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = e;
return true;
}
//集合错误长度这个值是 -2147483649
public static final int MAX_VALUE = 0x7fffffff;
//集合最大长度
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
/*这实现了ensureCapacity的非同步语义。该类中的同步方法可以在内部调用此方法以确保容量，而不会产生额外同步的开销。*/
private void ensureCapacityHelper(int minCapacity) {
// overflow-conscious code
//判断是否扩容，初始容器是10第11次添加才会触发扩容
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
//第11次添加这里传入的值是11
private void grow(int minCapacity) {
// overflow-conscious code
//elementData.length=10
int oldCapacity = elementData.length;
//capacityIncrement>0 false
//newCapactiy=10+10,在这能看出来，如果自己设置了增量
//那么每次扩容则按照增量值为标准
int newCapacity = oldCapacity + ((capacityIncrement > 0) ?capacityIncrement : oldCapacity);
//什么情况下这里才能<0如果没有传递增量，newCapctiy都是oldCapacity的两倍
//如果传递了，不能是0也不能是负数就算是1那么11-11也不<0
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
//这里表示如果新的容量大于了阈值这个阈值是Integer.MAX_VALUE - 8;
//到这里newCapacity肯定是正数也就是只有大于MAX_ARRAY_SIZE才是>0
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
//最后拷贝数组，ArrayList也是这个方法拷贝的，这次进去看看
elementData = Arrays.copyOf(elementData, newCapacity);
}
private static int hugeCapacity(int minCapacity) {
//这个条件不会满足
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
//如果大于了则是负数其实也是错误的，否则使用最大值MAX_ARRAY_SIZE
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
//这是Arrays的方法
public static <T> T[] copyOf(T[] original, int newLength) {
return (T[]) copyOf(original, newLength, original.getClass());
}
//三个参数是原数组，扩容长度，数组类型
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
@SuppressWarnings("unchecked")
//判断数组类型是不是Object如果是直接创建一个Object类型的数组
//如果不是则创建一个指定类型的数组，newInstance后边也是本地方法
//最后调用本地方法System.arraycopy。关于这个方法的参数在ArrayList
//中聊过这里不展开说了
T[] copy = ((Object)newType == (Object)Object[].class)
? (T[]) new Object[newLength]
: (T[]) Array.newInstance(newType.getComponentType(), newLength);
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}
原文：https://www.cnblogs.com/zumengjie/p/13630683.html