最近花了一点时间看了一下ArrayList的源码和扩容原理，这里分享一下
有JDK8和JDK14两个版本的源码哦(干货满满)
1. 观察构造函数
查看源码如下(JDK1.8)：
/**
* 默认初始容量大小
*/
private static final int DEFAULT_CAPACITY = 10;
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
/**
*默认构造函数，使用初始容量10构造一个空列表(无参数构造)
*/
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
//也就是上面的空数组
}
/**
* 带初始容量参数的构造函数。（用户自己指定容量）
*/
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {//初始容量大于0
//创建initialCapacity大小的数组
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {//初始容量等于0
//创建空数组
this.elementData = EMPTY_ELEMENTDATA;
} else {//初始容量小于0，抛出异常
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
/**
*构造包含指定collection元素的列表，这些元素利用该集合的迭代器按顺序返回
*如果指定的集合为null，throws NullPointerException。
*/
public ArrayList(Collection<? extends E> c) {
elementData = c.toArray();
if ((size = elementData.length) != 0) {
// c.toArray might (incorrectly) not return Object[] (see 6260652)
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
// replace with empty array.
this.elementData = EMPTY_ELEMENTDATA;
}
}可以发现，当我们new一个ArrayList的时候是创建的一个空的Object数组
拓展
JDK1.7以前默认创建的是长度为10的Object数组，采用的是设计模式类似于单例的饿汉式
而1.8以后采用的类似于单例的懒汉式
2. 分析add方法(JDK1.8)
/**
* 将指定的元素追加到此列表的末尾。
*/
public boolean add(E e) {
//添加元素之前，先调用ensureCapacityInternal方法
ensureCapacityInternal(size + 1); // Increments modCount!!
//这里看到ArrayList添加元素的实质就相当于为数组赋值
elementData[size++] = e;
return true;
}PS: Java11以后移除了下面的两个方法
2.1 ensure Capacity Internal方法
//得到最小扩容量
private void ensureCapacityInternal(int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
// 获取默认的容量和传入参数的较大值
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}2.2 ensure Explicit Capacity方法
//判断是否需要扩容
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
//调用grow方法进行扩容，调用此方法代表已经开始扩容了
grow(minCapacity);
}分析
- 第一执行add的时候，
elementData.length(元素数量)为0。又因为执行了ensureCapacityInternal()方法，minCapacity变为10，此时2.2中if判断成立，进入grow方法，容量变为10(elementData.length=10) - 之后10次add之前的2.2中的if判断不会成立，因此不会扩容
- 第11次add，此时传入的
minCapacity值为11，因此if再次成立，继续进行扩容
2.3 grow方法
/**
* 要分配的最大数组大小
*/
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
/**
* ArrayList扩容的核心方法。
*/
private void grow(int minCapacity) {
// oldCapacity为旧容量，newCapacity为新容量
int oldCapacity = elementData.length;
//将oldCapacity 右移一位，其效果相当于oldCapacity /2，
//我们知道位运算的速度远远快于整除运算，整句运算式的结果就是将新容量更新为旧容量的1.5倍，
int newCapacity = oldCapacity + (oldCapacity >> 1);
//然后检查新容量是否大于最小需要容量，若还是小于最小需要容量，那么就把最小需要容量当作数组的新容量，
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
// 如果新容量大于 MAX_ARRAY_SIZE,进入(执行) `hugeCapacity()` 方法来比较 minCapacity 和 MAX_ARRAY_SIZE，
//如果minCapacity大于最大容量，则新容量则为`Integer.MAX_VALUE`，否则，新容量大小则为 MAX_ARRAY_SIZE 即为 `Integer.MAX_VALUE - 8`。
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// minCapacity is usually close to size, so this is a win:
elementData = Arrays.copyOf(elementData, newCapacity);
}分析
可以看见每次扩容之后容量都会变为原来的1.5倍左右，并且使用了移位运算符来代替除法运算
- 当 add 第 1 个元素时，
oldCapacity为 0，经比较后第一个 if 判断成立，newCapacity=minCapacity(为 10)。但是第二个 if 判断不会成立，即newCapacity不比MAX_ARRAY_SIZE大，则不会进入hugeCapacity方法。数组容量为 10，add 方法中return true,size增为 1。 - 当 add 第 11 个元素进入 grow 方法时，
newCapacity为 15，比minCapacity（为 11）大，第一个 if 判断不成立。新容量没有大于数组最大size，不会进入hugeCapacity方法。数组容量扩为 15，add 方法中return true,size增为 11。 - 以此类推······
2.4 Arrays copy Of 方法
测试一下这个方法的作用
public class ArrayscopyOfTest {
public static void main(String[] args) {
int[] a = new int[3];
a[0] = 0;
a[1] = 1;
a[2] = 2;
int[] b = Arrays.copyOf(a, 10);
System.out.println("b.length"+b.length);
}
}可以看见不仅实现了数组复制，而且容量也变为了10
Arrays.copyOf()方法内部调用的是System.arraycopy()方法
//elementData:源数组;index:源数组中的起始位置;elementData：目标数组；index + 1：目标数组中的起始位置； size - index：要复制的数组元素的数量；
System.arraycopy(elementData, index, elementData, index + 1, size - index);2.5 huge Capacity方法
这个只有在新容量大于MAX_ARRAY_SIZE也就是Integer.MAX_VALUE - 8时，为了防止1.5倍扩容导致Integer溢出而采取的操作
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
//对minCapacity和MAX_ARRAY_SIZE进行比较
//若minCapacity大，将Integer.MAX_VALUE作为新数组的大小
//若MAX_ARRAY_SIZE大，将MAX_ARRAY_SIZE作为新数组的大小
//MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}可以看到如果minCapacity大于最大容量(MAX_ARRAY_SIZE)，则新容量直接到了Integer.MAX_VALUE，否则为MAX_ARRAY_SIZE
3 Java 14版本add方法
2.1 看看add的源码
public boolean add(E e) {
modCount++;
add(e, elementData, size);
return true;
}
private void add(E e, Object[] elementData, int s) {
if (s == elementData.length)
elementData = grow();
elementData[s] = e;
size = s + 1;
}可以看见没有了上面两个判断的方法，而是清晰的直接判断满不满，满了就grow一下，再填充数据进去
2.2 grow方法
private Object[] grow() {
return grow(size + 1);
}
private Object[] grow(int minCapacity) {
int oldCapacity = elementData.length;
if (oldCapacity > 0 || elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
int newCapacity = ArraysSupport.newLength(oldCapacity,
minCapacity - oldCapacity, /* minimum growth */
oldCapacity >> 1 /* preferred growth */);
return elementData = Arrays.copyOf(elementData, newCapacity);
} else {
return elementData = new Object[Math.max(DEFAULT_CAPACITY, minCapacity)];
}
}
可以看见判断增加多少不再是使用上面那样的两个方法了，而是使用了ArraysSupport类中的静态方法newLength()
2.3 new Length方法
public static int newLength(int oldLength, int minGrowth, int prefGrowth) {
// assert oldLength >= 0
// assert minGrowth > 0
// 传入的oldLength是oldCapacity，
// minGrowth是minCapacity - oldCapacity，
// prefGrowth是oldCapacity/2 同样也是采用的移位运算
int newLength = Math.max(minGrowth, prefGrowth) + oldLength;
if (newLength - MAX_ARRAY_LENGTH <= 0) {
return newLength;
}
return hugeLength(oldLength, minGrowth);
}
private static int hugeLength(int oldLength, int minGrowth) {
int minLength = oldLength + minGrowth;
if (minLength < 0) { // overflow
throw new OutOfMemoryError("Required array length too large");
}
if (minLength <= MAX_ARRAY_LENGTH) {
return MAX_ARRAY_LENGTH;
}
return Integer.MAX_VALUE;
}选取扩容后新大小(newLength)的逻辑为
- 在
minCapacity(oldCapacity + 1)和prefGrowth（1.5倍oldCapacity）中选择大的那个 如果
newLength小于MAX_ARRAY_LENGTH则就用newLengthMAX_ARRAY_LENGTH的定义和之前版本的一样
不然的话就进入
hugeLength方法处理- 如果增加之后大小越界则直接报OOM error
- 不越界的话就将
Integer.MAX_VALUE作为新的容量