【Java】 ArrayList核心扩容机制和源码分析

（1）ArrayList中维护了一个Object类型的数组elementData，add方法添加的属性存放在elementData数组中。ArrayList有一个无参构造器ArrayList（ ）和一个有参构造器ArrayList（int）。
（2）ArrayList的扩容机制提高了性能，如果每次只扩充一个，那么频繁的插入会导致频繁的拷贝，降低性能，而ArrayList的扩容机制避免了这种情况。

import java.util.ArrayList;
public class ArrayListSource {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();//使用无参构造器创建ArrayList对象
        for (int i = 0; i <=10 ; i++) {  //使用for循环给list集合添加1-10数据
            list.add(i);
        }
        for (int i = 11; i <=15 ; i++) {  //使用for循环给list集合添加11-15数据
            list.add(i);
        }
        list.add(100);
        list.add(200);
    }
}

package java.util;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.function.UnaryOperator;
public class ArrayList extends AbstractList
implements List, RandomAccess, Cloneable, java.io.Serializable
{
private static final long serialVersionUID = 8683452581122892189L;

private static final int DEFAULT_CAPACITY = 10;

private static final Object[] EMPTY_ELEMENTDATA = {};
//用于默认大小空实例的共享空数组实例。
//我们把它从EMPTY_ELEMENTDATA数组中区分出来，以知道在添加第一个元素时容量需要增加多
少。
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

transient Object[] elementData; // non-private to simplify nested class
access

private int size;

public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {
//创建initialCapacity大小的数组
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
//创建空数组
this.elementData = EMPTY_ELEMENTDATA;
} else {
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}

public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

//下面是ArrayList的扩容机制
//ArrayList的扩容机制提高了性能，如果每次只扩充一个，
//那么频繁的插入会导致频繁的拷贝，降低性能，而ArrayList的扩容机制避免了这种情况。

public void ensureCapacity(int minCapacity) {
int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
// any size if not default element table
? 0
// larger than default for default empty table. It's already
// supposed to be at default size.
: DEFAULT_CAPACITY;
if (minCapacity > minExpand) {
ensureExplicitCapacity(minCapacity);
}
}
//得到最小扩容量
private void ensureCapacityInternal(int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
// 获取默认的容量和传入参数的较大值
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
//判断是否需要扩容
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
//调用grow方法进行扩容，调用此方法代表已经开始扩容了
grow(minCapacity);
}

private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

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;
//再检查新容量是否超出了ArrayList所定义的最大容量，
//若超出了，则调用hugeCapacity()来比较minCapacity和 MAX_ARRAY_SIZE，
//如果minCapacity大于MAX_ARRAY_SIZE，则新容量则为Interger.MAX_VALUE，否则，新
容量大小则为 MAX_ARRAY_SIZE。
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);
}
//比较minCapacity和 MAX_ARRAY_SIZE
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}

当创建ArrayList对象时，若使用的是无参构造器，则初始elementData容量为0，第一次添加，则扩容elementData容量为10，如需再次扩容，则扩容elementData容量为上一次容量的1.5倍。

import java.util.ArrayList;
public class ArrayListSource {
    public static void main(String[] args) {
        ArrayList list = new ArrayList(12);//使用有参构造器创建ArrayList对象，定义初始容量为12
        for (int i = 0; i <=10 ; i++) {  //使用for循环给list集合添加1-10数据
            list.add(i);
        }
        for (int i = 11; i <=15 ; i++) {  //使用for循环给list集合添加11-15数据
            list.add(i);
        }
        list.add(100);
        list.add(200);
    }
}

当创建ArrayList对象时，若使用的是有参构造器，则初始elementData容量为（int）中指定大小，如需扩容，则直接扩容为上一次elementData容量的1.5倍。

（1）当创建ArrayList对象时，若使用的是无参构造器，则初始elementData容量为0，第一次添加，则扩容elementData容量为10，如需再次扩容，则扩容elementData容量为上一次容量的1.5倍。
（2）当创建ArrayList对象时，若使用的是有参构造器，则初始elementData容量为（int）中指定大小，如需扩容，则直接扩容为上一次elementData容量的1.5倍。