ArrayList扩容机制

ArrayList扩容机制源码分析

首先在这里纠正一个问题，我发现很多博文在介绍ArrayList调用无参构造时，初始容量为10。其实这里是有问题的。实际调用了无参构造初始容量为0。来看源码

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

这段代码很简单，很容易理解，就是将DEFAULTCAPACITY_EMPTY_ELEMENTDATA赋值给elementData。那么这两个是什么呢？

    private static final long serialVersionUID = 8683452581122892189L;

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

    /**
     * Shared empty array instance used for empty instances.
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};

    /**
     * Shared empty array instance used for default sized empty instances. We
     * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
     * first element is added.
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    /**
     * The array buffer into which the elements of the ArrayList are stored.
     * The capacity of the ArrayList is the length of this array buffer. Any
     * empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
     * will be expanded to DEFAULT_CAPACITY when the first element is added.
     */
    transient Object[] elementData; // non-private to simplify nested class access

    /**
     * The size of the ArrayList (the number of elements it contains).
     *
     * @serial
     */
    private int size;

elementData就是ArrayList的数据存放的数组。DEFAULTCAPACITY_EMPTY_ELEMENTDATA 是一个专门用来初始化的空数组。所以当new ArrayList()时，ArrayList的容量是0。
其次下来看扩容，当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;
    }

很多人认为add方法就是将元素添加到数组里面，实际这里第一步并不是添加元素，而是调用ensureCapacityInternal方法扩容，这里的size变量就是elementData数组的实际容量大小。 继续往下看。

    private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

ensureCapacityInternal方法中调用了ensureExplicitCapacity方法，ensureExplicitCapacity方法中又调用了calculateCapacity方法。那就先看看这个calculateCapacity方法。

    private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }

calculateCapacity方法中，首先做了一个if判断，这个判断就是为无参构造做的下文，因无参构造将DEFAULTCAPACITY_EMPTY_ELEMENTDATA赋值给了elementData ，所以这里自然就是true，这时候会将DEFAULT_CAPACITY这个变量和传入的minCapacity变量做比较，返回最大值。DEFAULT_CAPACITY就是自定义的默认初始容量，minCapacity就是刚才的size+1。如果if返回是false，那么就返回minCapacity。总结这段代码的意义就是看是否是无参构造new出来的对象。继续往下看

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

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

ensureExplicitCapacity方法中，具体判断了是否需要扩容，modCount++这里对于扩容不重要，所以这里不介绍。
紧接着下面就是一个if判断，这个if判断也很容易理解。就是将如今需要的容量和原来的容量做比较，如果如今需要的容量小那么就调用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
        //1
        int oldCapacity = elementData.length;
        //2
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        //3
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        //4
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        //5
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

第1段代码，就是将原来的容量保存到oldCapacity变量中。
第2段代码，就是将现在新的容量保存到newCapacity 变量中。oldCapacity + (oldCapacity >> 1)，这也就是大家所说的扩容1.5倍的神奇代码。哈哈，其实也没啥神奇的，也就是将原容量右移1位，也就是/2。然后在加上原来的容量。
第3段代码，是个if语句 这也是为初始调用无参构造做的下文。因为0右移位在加上0还是0，所以这里对newCapacity 和minCapacity 做了比较，如果minCapacity 大，也就说明现在还是无参构造初始化后第一次调用add方法。其次也就对第三种构造方法做了下文，这里就不对这个构造进行讲解了。
第4段代码，这个自我理解是定义了边界，MAX_ARRAY_SIZE看意思应该是jdk自带的一个大的边界值。和newCapacity 做比较用来看是否超出这个值。
第5段代码，通过Arrays.copyOf方法使用新容量来复制数组。


这里做出声明，此篇文章jdk版本为1.8。