1 add源码解析

在【ArrayList源码】ArrayList构造方法中，ArrayList无参构造方法默认是一个空数组，但注释说是容量为10的数组。其实ArrayList的容量是在调用add方法时初始化的。add方法是List接口中声明的通用方法。ArrayList的add源码如下所示：

/**
     * Appends the specified element to the end of this list.
     *添加指定元素到这个列表中
     * @param e element to be appended to this list
     * @return <tt>true</tt> (as specified by {@link Collection#add})
     */
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

size是当前集合拥有的元素个数（不是容量大小，且未算进准备新增的元素）。在add方法中调用了ensureCapacityInternal对ArrayList进行扩容，size+1是保证新进入的元素能满足要求。接下来看ensureCapacityInternal方法：

    private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {//#1
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);//#2
        }

        ensureExplicitCapacity(minCapacity);//#3
    }

• 第#1行判断elementData是否是一个空数组（初始化容量为0，或者调用无参构造函数），如果是，则执行第#2行
• 第#2行选取minCapacity和DEFAULT_CAPACITY之间一个比较大的值。其中DEFAULT_CAPACITY是一个静态的值为10的常量

 /**
     * Default initial capacity.
     */
    private static final int DEFAULT_CAPACITY = 10;

• 第#3行执行ensureExplicitCapacity方法，该方法源码如下：

    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)//#1
            grow(minCapacity);//#2
    }

• 第#1行，如果传进来的容量大于elementData的容量（这里是容量，不是element里面元素的个数），则执行第#2行。
• 第#2行，调用grow方法，grow方法源码如下所示：

   /**
     * Increases the capacity to ensure that it can hold at least the
     * number of elements specified by the minimum capacity argument.
     *
     * @param minCapacity the desired minimum capacity
     */
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;//#1
        int newCapacity = oldCapacity + (oldCapacity >> 1);//#2
        if (newCapacity - minCapacity < 0)//#3
            newCapacity = minCapacity;//#4
        if (newCapacity - MAX_ARRAY_SIZE > 0)//#5
            newCapacity = hugeCapacity(minCapacity);//#6
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);//#7
    }

• 第#1行，将扩容前elementData数组容量赋值给oldCapacity
• 第#2行，将oldCapacity左移一位，然后再加上oldCapacity，最后赋值给newCapacity。就是将oldCapacity扩容1.5倍赋值给newCapacity。
• 第#3行，如果扩充后的容量newCapacity比传进来的参数minCapacity还小，则直接使用minCapacity。这种情况发生在ArrayList容量为空的情况，即oldCapacity=0，minCapacity=1时。
• 第#5行如果扩容后新的容量大于MAX_ARRAY_SIZE，则调用hugeCapacity方法给newCapacity赋值。MAX_ARRAY_SIZE初始化如下：

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

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

源码很简单，如果minCapacity 小于0，则抛出异常；否则如果minCapacity 大于MAX_ARRAY_SIZE，则返回Integer.MAX_VALUE，否则返回MAX_ARRAY_SIZE

• 第#6行调用Arrays.copyof方法，即复制原数组到一个新容量的大数组中。

2 以ArrayList的空构造方法为例讲解扩容流程

声明并创建ArrayList对象

ArrayList<String> list = new ArrayList();

会调用ArrayList的空构造方法

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

在空构造方法中会给elementData（ArrayList存储元素的数组）初始化一个空的Object数组，DEFAULTCAPACITY_EMPTY_ELEMENTDATA初始化如下：

  private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

调用add方法，自动扩容

list.add("ceshi")

add源码如下：

    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

这里调用ensureCapacityInternal扩容，size指的是elementData中元素的个数（不是容量），size+1是保证要添加的元素e也能满足。扩充容量完成后，将元素e添加到elementData数组中，然后返回true。接下来看看ensureCapacityInternal方法：

   private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

判断elementData是不是一个空数组，很显然是一个空数组，所以比较DEFAULT_CAPACITY（值为10）和minCapacity（值为1）的大小并将比较大的值赋值给minCapacity，所以最终minCapacity=10。然后调用ensureExplicitCapacity方法。

   private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

minCapacity(值为10)减去elementData.length（值为0）肯定是大于0，所以执行grow方法

    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;//oldCapacity = 0
        int newCapacity = oldCapacity + (oldCapacity >> 1);// newCapacity = 0;
        if (newCapacity - minCapacity < 0)//#1
            newCapacity = minCapacity;//#2
        if (newCapacity - MAX_ARRAY_SIZE > 0)//#3
            newCapacity = hugeCapacity(minCapacity);//#4
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);//#5
    }

如上注释所示

• 第#1行newCapacity （值为0）减去minCapacity （值为10）肯定是小于0的，所以会执行第#2行
• 第#2行newCapacity = 10；
• 第#3行肯定是小于0的，所以不会执行第#4行
• 第#5行，将空的elementData数组扩容为容量为10的数组。

3总结

• ArrayList的扩容是在调用add方法时进行扩容的
• 调用ArrayList的空构造方法初始化ArrayList的时候，ArrayList会被初始化为一个空的Object数组
• 调用ArrayList的空构造方法初始化ArrayList的时候，在add时会将ArrayList扩容为默认的10
• ArrayList每次扩容为当前容量的1.5倍