源码分析：ArrayList扩容机制

ArrayList是我比较常用的Java容器，最近研究了一下它的底层实现部分。关于ArrayList的继承关系请参考上一篇文章Java容器概览。

成员变量

private static final long serialVersionUID = 8683452581122892189L;
//默认的初始容量为10
private static final int DEFAULT_CAPACITY = 10;
//定义一个空的数组实例以供其他需要用到空数组的地方调用
private static final Object[] EMPTY_ELEMENTDATA = {};
//定义一个空数组，跟前面的区别就是这个空数组是用来判断ArrayList第一添加数据的时候要扩容多少。默认的构造器情况下返回这个空数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//数据存的地方，它的容量就是这个数组的长度，同时只要是使用默认构造器（DEFAULTCAPACITY_EMPTY_ELEMENTDATA ）第一次添加数据的时候容量扩容为DEFAULT_CAPACITY = 10
transient Object[] elementData; 
// ArrayList中实际数据的数量
private int size;  

构造方法

public ArrayList()  //无参构造函数,默认容量为10
{
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
public ArrayList(Collection c)  //创建一个包含collection的ArrayList
{
    elementData = c.toArray(); //返回包含c所有元素的数组
    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);//复制指定数组，使elementData具有指定长度
    } 
    else
    {
        //c中没有元素
        this.elementData = EMPTY_ELEMENTDATA;
    }
}
public ArrayList(int initialCapacity) //带初始容量大小的构造函数
{
    if (initialCapacity > 0)   //初始容量大于0,实例化数组
    {
        this.elementData = new Object[initialCapacity];
    } 
    else if (initialCapacity == 0) //初始化等于0，将空数组赋给elementData
    {
        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;
}
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(minCapacity);
}
//ArrayList扩容的核心方法，此方法用来决定扩容量
private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    //注意此处扩充capacity的方式是将其向右一位再加上原来的数，实际上是扩充了1.5倍
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    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);
}  
private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
        MAX_ARRAY_SIZE;
    }

总结一下：

• 当前数组是由默认构造方法生成的空数组并且第一次添加数据。此时minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity)=10。
• 当前数组是由自定义初始容量构造方法创建并且指定初始容量为0。此时minCapacity等于1，if (elementData== DEFAULTCAPACITY_EMPTY_ELEMENTDATA) 为假，这边可以看到一个严重的问题，一旦我们执行了初始容量为0，那么根据下面的算法前四次扩容每次都 +1，在第5次添加数据进行扩容的时候才是按照当前容量的1.5倍进行扩容。
• 当扩容量（newCapacity）大于ArrayList数组定义的最大值后会调用hugeCapacity来进行判断。如果minCapacity已经大于Integer的最大值（溢出为负数）那么抛出OutOfMemoryError（内存溢出）否则的话根据与MAX_ARRAY_SIZE的比较情况确定是返回Integer最大值还是MAX_ARRAY_SIZE。这边也可以看到ArrayList允许的最大容量就是Integer的最大值（-2的31次方~2的31次方减1）。