ArrayList的构造函数

ArrayList 有三种构造函数

默认构造函数
带初始容量参数的构造函数
包含指定集合元素的构造函数

源码如下：

    /**
     * 初始化容量大小.
     */
    private static final int DEFAULT_CAPACITY = 10;

    /**
     * 用于空实例的共享空数组实例
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};

    /**
     * 用于默认大小的空实例的共享空数组实例。
	 * 将它与EMPTY_ELEMENTDATA区别开来，以了解添加第一个元素时要扩容多少。
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};


    /**
     * 存储ArrayList元素的数组缓冲区。ArrayList的容量就是这个数组缓冲区的长度。
     * 当添加第一个元素时，任何具有elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA的空ArrayList都会扩展为DEFAULT_CAPACITY。
     */
    transient Object[] elementData; // non-private to simplify nested class access

    /**
     * ArrayList的长度 (the number of elements it contains).
     */
    private int size;

    /**
     * 带初始容量参数的构造函数。（用户自己指定容量）
     *
     * @param  initialCapacity  列表的初始容量
     * @throws IllegalArgumentException 如果指定的初始容量为负值
     */
    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);
        }
    }

    /**
     * 默认构造函数，使用初始容量10构造一个空列表(无参数构造)
     */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

   /**
    * 按照集合的迭代器返回的顺序，构造一个包含指定集合元素的列表。
    * 如果指定的集合为null，throws NullPointerException。
    */
    public ArrayList(Collection<? extends E> c) {
        Object[] a = c.toArray();
        if ((size = a.length) != 0) {
            if (c.getClass() == ArrayList.class) {
                elementData = a;
            } else {
                elementData = Arrays.copyOf(a, size, Object[].class);
            }
        } else {
            // replace with empty array.
            elementData = EMPTY_ELEMENTDATA;
        }
    }

注：以无参构造函数创建ArrayList时，实际上会默认创建一个空的数组。只有对数据进行添加数据时才会分配真正的容量，大小为十。 在下文的add()时会分析这一点。

ArrayList的扩容机制

在此以无参构造函数为例创建ArrayList

由于无参构造函数起初默认创建的是空的数组，所以需要用到add()方法来添加数据

add()方法

    /**
     * 将指定的元素附加到列表的末尾。
     */
    public boolean add(E e) {
        //添加元素之前，先调用ensureCapacityInternal方法
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

add()方法调用的函数

calculateCapacity(Object[] elementData, int minCapacity)
ensureCapacityInternal(int minCapacity)
ensureExplicitCapacity(int minCapacity)

可以看到调用add 方法时首先调用了ensureCapacityInternal(size + 1)，然后ensureCapacityInternal调用calculateCapacity ，最后调用ensureExplicitCapacity判断是否需要扩容，elementData.length的长度初始值为10，当minCapacity>elementData.length时开始扩容。

private static int calculateCapacity(Object[] elementData, int minCapacity) {
    // 判断数组缓冲区elementData是否等于共享空数组实例
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        // 获取默认的容量（10） 和传入参数的较大值
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    // 否则返回minCapacity
    return minCapacity;
}

//得到最小扩容量
private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

// 判断是否扩容
private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

    // overflow-conscious code
    //调用grow方法进行扩容，调用此方法代表已经开始扩容了
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

以具体的数据为例：

当我们要 add 进第 1 个元素到 ArrayList 时，elementData.length 为 0 （因为还是一个空的 list），因为执行了 ensureCapacityInternal() 方法，进入calculateCapacity后得到 minCapacity = 10。

然后进入ensureExplicitCapacity方法，此时，minCapacity - elementData.length > 0成立

所以会进入 grow(minCapacity) 方法进行扩容。

当 add 第 2 个元素时，minCapacity 为 2，此时 e lementData.length(容量)在添加第一个元素后扩容成 10 了。此时，minCapacity - elementData.length > 0 不成立，所以不会进入（执行）grow(minCapacity) 方法。
添加第 3、4···到第 10 个元素时，依然不会执行 grow 方法，数组容量都为 10。

直到添加第 11 个元素，minCapacity(为 11)比 elementData.length（为 10）要大。进入 grow 方法进行扩容。

grow方法

/**
* 要分配的最大数组大小
*/
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

/**
* ArrayList扩容的核心方法。
*/
private void grow(int minCapacity) {
    // overflow-conscious code
    // oldCapacity为旧容量，newCapacity为新容量
    int oldCapacity = elementData.length;
// 将旧容量右移一位，表示除以二
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);
}

hugeCapacity()方法

private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // overflow
    throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
    Integer.MAX_VALUE :
    MAX_ARRAY_SIZE;
}

由于int newCapacity = oldCapacity + (oldCapacity >> 1); ，因此ArrayList每次扩容都是原来的1.5倍，偶数就是1.5倍，奇数会小于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。

以此类推，当add到16个元素的时候，newCapacity为 15+7=22，比minCapacity大，第一个 if 判断不成立。新容量没有大于数组最大 size，不会进入 hugeCapacity 方法。数组容量扩为 22，add 方法中 return true,size 增为 16。

hugeCapacity方法

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;
}

文章参考：javaguide.cn/java/collec…

ArrayList扩容机制分析

ArrayList的构造函数

ArrayList的扩容机制

add()方法

grow方法