ArrayList
初始化:
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; // 默认的空数组
transient Object[] elementData; // 用于存放集合元素的数组
// 指定初始化容量的构造器
public ArrayList(int initialCapacity) {
// 判断给定的初始化容量
if (initialCapacity > 0) {
// 若大于 0,新创建一个指定容量的数组赋值给 elementData
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
// 若等于 0,将默认空数组赋值给 elementData
this.elementData = EMPTY_ELEMENTDATA;
} else {
// 否则抛出异常
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
// 未指定初始化容量的无参构造器
public ArrayList() {
// 将默认空数组赋值给 elementData
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
第一次添加元素:
private int size; // 集合中包含元素的个数,默认值为 0
// 第一次添加元素
public boolean add(E e) {
ensureCapacityInternal(size + 1); // 判断新增加元素时,容量是否满足
elementData[size++] = e; // 将元素添加到数组中
return true;
}
private void ensureCapacityInternal(int minCapacity) { // minCapacity = 1
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
private static final int DEFAULT_CAPACITY = 10;
// 第一次添加时:elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;minCapacity = 1
private static int calculateCapacity(Object[] elementData, int minCapacity) {
// 判断是否是第一次添加元素
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
// 如果是第一次添加,返回 10 和 minCapacity(1)最大值,也就是指定输入默认容量为 10
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
// 第一次添加时:minCapacity = 10
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// 第一次添加时,数组是一个空数组,容量为 0,所以可以进入此判断
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
// 第一次添加时:minCapacity = 10
// 用于初始化数组
private void grow(int minCapacity = 10) {
int oldCapacity = elementData.length; // 将 elementData.length(0) 赋值给 oldCapacity
// 从这可以看出新的容量是在就的容量基础上增加 50%,若第一次添加 newCapacity = 0
int newCapacity = oldCapacity + (oldCapacity >> 1);
// 第一次添加:newCapacity = 0;minCapacity = 10,可以进入判断
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity; // 将 minCapacity(10)赋值给新容量
// 该判断是用于判断容量是否超过最大容量
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// 创建新数组,容量为 newCapacity,第一次添加时为 10
elementData = Arrays.copyOf(elementData, newCapacity);
}
Vector
初始化:
protected int capacityIncrement; // 每次扩容的增量,未指定,默认为 0
public Vector() {
this(10); // 使用无参构造器创建 Vector 时,默认指定容量为 10,并调用自定义指定容量的有参构造器
}
// 自定义容量的有参构造器
public Vector(int initialCapacity) {
this(initialCapacity, 0); // 调用自定义容量,并且自定义增量的有参构造器,若为指定,增量为 0
}
// 调用自定义容量,并且自定义增量的有参构造器
public Vector(int initialCapacity, int capacityIncrement) {
super();
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
this.elementData = new Object[initialCapacity]; // 初始化数组,容量为 10
this.capacityIncrement = capacityIncrement; // 将形参中的增量辅助给成员变量 capacityIncrement
}
第一次添加元素:
protected int elementCount; // 元素的个数,默认为 0
public synchronized boolean add(E e) {
modCount++;
ensureCapacityHelper(elementCount + 1); // 判断新增加元素时,容量是否满足
elementData[elementCount++] = e; // 将元素添加到数组中
return true;
}
private void ensureCapacityHelper(int minCapacity) { // 第一次添加:minCapacity = 1
if (minCapacity - elementData.length > 0) // 判断当前容量是否满足,第一次添加:1 - 10 < 0 ==> false
grow(minCapacity); // 若添加的元素个数大于默认容量 10,执行该方法,进行扩容
}
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8; // 数组最大容量
private void grow(int minCapacity) {
int oldCapacity = elementData.length; // 将添加前数组的容量赋值给: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);
}