ArrayList扩容源码解析(JDK1.8)

环境：JDK1.8

 

先看看几个ArrayList内部成员变量：

ArrayList的容量大小

 

默认的初始容量为10：DEFAULT_CAPACITY = 10。

 

 

对于所有的空实例可共享的空阵列实例EMPTY_ELEMENTDATA。

 

对于所有的空实例可共享的空阵列实例DEFAULTCAPACITY_EMPTY_ELEMENTDATA，不同于EMPTY_ELEMENTDATA在于该数组可记录第一个元素被添加的时候，容器至少需要多大的空间

 

存储ArrayList元素的数组缓冲区，ArrayList的容量即为该阵列数据缓冲区的长度。当添加第一个元素时，任意刚开始容量为DEFAULTCAPACITY_EMPTY_ELEMENTDATA的空ArrayList的容量都会扩充到DEFAULT_CAPACITY，也就是10。

 

内部数组可以分配的最大容量MAX_ARRAY_SIZE=Integer.MAX_VALUE(为整型数最大值)-8，为何要减8呢？因为这个8的空间用于存储数组_length字段。

 

查看add(E e)方法：

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

 

查看ensureCapacityInternal(int minCapacity)方法、ensureExplicitCapacity(int minCapacity)方法以及calculateCapacity(Object[] elementData, int minCapacity)方法：

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

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

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

 

ensureExplicitCapacity方法实现：

1. modCount++。

2. 如果需扩充的容量大小minCapacity大于原内部数组大小，则调用grow方法。

 

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

 

calculateCapacity方法实现：

1. 传入原内部数组elementData和需扩充的容量大小minCapacity。

2. 如果elementData为空数组则比较默认初始容量DEFAULT_CAPACITY=10与参数minCapacity的大小，取大返回。

3. 如果elementData不为空，则返回minCapacity。

 

查看grow(int minCapacity)方法：

增加容量以确保ArrayList能保留指定的最小容量参数下的元素数量

    /**
     * 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;
        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);
    }

 

grow方法实现：

a. 取得elementData的长度为原容量oldCapacity。

b. oldCapacity >> 1表示位运算，为oldCapacity转换成二进制后向右移动1位，当前可理解为java中oldCapacity / 2的结果，以后会专门写一篇帖子来说明位运算。故可以理解为新容量newCapacity为oldCapacity+1/2的oldCapacity，此时再比较newCapacity和参数要求容量(至少得需要到参数要求的容量大小，不然无法将元素存放到ArrayList)，如果小于则newCapacity设置为minCapacity，否则再比较newCapacity和MAX_ARRAY_SIZE，如果前者大于后者，则查看hugeCapacity(int minCapacity)方法

当容量参数小于0，抛出异常OutOfMemoryError()。如果参数大于MAX_ARRAY_SIZE，则返回Integer.MAX_VALUE(为整型数最大值)，否则返回MAX_ARRAY_SIZE。最后将返回值赋给newCapacity

c. 将原内部数组和新的容量长度融合为新的内部数组对象(内容不变，容量扩充)。

结论：

1. ArrayList对象群初始化时可不传参，共享内部数组对象，大小为空。

2. 当添加第一个元素时，内部扩容为默认大小10。

3. 当添加到大于10个元素时，则以后每次需扩容时，规则为newCapacity(新容量) = oldCapacity(原容量) +oldCapacity/2。

4. 将最新添加的元素放入当前ArrayList内部数组的size++位，即elementData[size++] = e;

 

额外说明：ArrayList从字面上看，底层是用数组实现的，增删查等操作也和数组的这类操作特性一致。

 

打个比方：

1. 添加第1个元素则内部数组扩充为默认大小10即elementData的大小为10。

2. 添加第11个元素时，则一直执行到grow方法，传参为11，oldCapacity为10，newCapacity变为15，elementData的大小为15，size当下为15，elementData[size++] = e，设置第11个数组元素。

3. 添加第16个元素时，则一直执行到grow方法，传参为16，oldCapacity为15，newCapacity变为22，elementData的大小为22，size当下为15，elementData[size++] = e，设置第16个数组元素。

以此类推...

 

解决具体面试题：

	public static ArrayList<Integer> getIntegerList(int capacity) {
		ArrayList<Integer> list = new ArrayList<Integer>();
		if (capacity <= 0) {
			return list;
		}
		for (int i = 0; i < capacity; i++) {
			list.add(i);
		}
		return list;
	}
	public static void main(String[] args) {
		getIntegerList(64);
	}

 

问题：以上程序中的list扩容了几次？

结合上述内容，则可以继续推倒：

4. 当添加第23个元素时，则newCapacity变为33，elementData的大小为33，设置第23个数组元素。

5. 当添加第34个元素时，则newCapacity变为51，elementData的大小为51，设置第34个数组元素。

6. 当添加第52个元素时，则newCapacity变为78，elementData的大小为78，设置第52个数组元素。

64在第78个元素之前，则经过6次扩容即可满足list.add(63)的需求。

答案为：6次