扩容机制
1、new ArrayList()无参构造,初始化大小为0,在第一次插入时,初始化大小为10,每次扩容为上次的1.5倍
2、 new ArrayList(3)有参构造,初始化大小为指定个数(3),每次扩容为上次的1.5倍
3、1.5倍为取整,舍弃小数
参数说明
// 初始化集合大小
private static final int DEFAULT_CAPACITY = 10;
//
private static final Object[] EMPTY_ELEMENTDATA = {};
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
// 存放元素 transient表示瞬间、短暂,表示不会被序列化
// 第一次添加元素或者扩容后,无值的用null填充,假设集合容量为10,无值的位置用null填充,最后elementData的长度为10
transient Object[] elementData; // non-private to simplify nested class access
private int size;
初始化
List<Object> list1 = new ArrayList<>(); // 无参
List<Object> list2 = new ArrayList<>(8); // 指定list大小
List<Object> list3 = new ArrayList<>(list1); // list
源码分析
初始化源码
// 无参构造时 elementData 初始化为{} 空集合,在第一次添加元素时才会扩容数组容量为10
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
// 指定数组大小
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {
// 直接初始化 例如initialCapacity为3 则elementData={null,null,null}
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
this.elementData = EMPTY_ELEMENTDATA;
} else {
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
add方法
public boolean add(E e) {
// 先确认是否需要扩容
ensureCapacityInternal(size + 1); // Increments modCount!!
// 存放元素 后++ 运行后再执行++操作
elementData[size++] = e;
return true;
}
// 指定下标存放
public void add(int index, E element) {
rangeCheckForAdd(index);
ensureCapacityInternal(size + 1); // Increments modCount!!
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
elementData[index] = element;
size++;
}
// ensureCapacityInternal方法 minCapacity参数为插入前集合内元素个数+1
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
// 返回集合最小容量 elementData为{}时返回10 否则则为新插入数据的下标
private static int calculateCapacity(Object[] elementData, int minCapacity) {
// elementData为{} 空数组
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
// 比较大小 返回大的
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
private void ensureExplicitCapacity(int minCapacity) {
// 集合修改次数
modCount++;
// 集合最小容量小于目前的数据长度,则不需要考虑扩容
// overflow-conscious code
if (minCapacity - elementData.length > 0)
// 扩容
grow(minCapacity);
}
grow 扩容方法
// 第一次add时minCapacity=10
private void grow(int minCapacity) {
// 老集合容量 第一次添加为0
int oldCapacity = elementData.length;
// 新容量 = 老容量 + 老容量/2(小数时取整,舍弃小数) 第一次添加新容量为0
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0)
// 新容量 < 集合最小容量 则新容量大小=集合最小容量
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
// 新容量 > 最大容量
newCapacity = hugeCapacity(minCapacity);
// 将elementData集合大小扩容到newCapacity
// 第一次add时 最后生成{null,null,null...} 10个null
// 假设有值 {1,2,...,10} 扩容1.5倍后会变成 {1,2,...,10,null,null,null,null,null} 无值用null填充
elementData = Arrays.copyOf(elementData, newCapacity);
}