【Java基础】ArrayList 扩容原理

一、前言

面试中经常问到的问题之一就是List的扩容机制了，他是怎么做到扩容的，大家都能答出来底层是数组，复制一个数组来扩容，但是再具体一点来说，大家就不知道该怎么说了，如果不看源码说这么多确实就差不多了，但是看了源码你会说的更多，更详细，更具体，本篇主要看的是jdk1.8  至于其他版本大同小异，看看就知道了，言归正传。至于如何查看ArrayList源码，自己实例化一个进去看就行了。。。

 

二、List扩容实现步骤

总的来说就是分两步：

1.扩容： 把原来的数组复制到另一个内存空间更大的数组中；

 2.添加元素： 把新元素添加到扩容以后的数组中。

 

三、源码分析

1.首先提供部分属性供大家参考：

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    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

 

2.分析ArrayList两个构造方法：

//无参构造：
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;//由上可知为空数组
}
 

//带参构造：
public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) {
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    }
}

在无参构造中，我们看到了在用无参构造来创建对象的时候其实就是创建了一个空数组，长度为0，

在有参构造中，传入的参数是正整数就按照传入的参数来确定创建数组的大小，否则异常。

3.扩容的方法add（）：

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

其实add方法就两，

第一步：增加数组长度；

第二步：添加元素到数组，第二步没什么说的，我们看看ensureCapacityInternal(int minCapacity)这个增加长度的方法。

4.ensureCapacityInternal(int minCapacity)方法：

 private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {//如果为空数组
            return Math.max(DEFAULT_CAPACITY, minCapacity); //默认值是10为容量
        }
        return 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);//这个是扩增容量的方法
    }

这个地方我们看到了，如果在添加的时候远数组是空的，就直接给一个10的长度，否则的话就+1。

5.grow（）方法：

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

这个地方注意这一句 

     int newCapacity = oldCapacity + (oldCapacity >> 1);

    oldCapacity >> 1    右移运算符，原来长度的一半 再加上原长度也就是每次扩容是原来的1.5倍；

之前的所有都是确定新数组的长度，确定之后就是把老数组copy到新数组中，这样数组的扩容就结束了；

以上的一切都是ArrayList扩容的第一步，第二步就没啥说的了，就是把需要添加的元素添加到数组的最后一位。

 

四、实战例题

 

ArrayList list = new ArrayList(20);中的list扩充几次？

解答：这种是指定数组大小的创建，创建时直接分配其大小，没有扩充。 一次性为创建了传入的数字的长度的数组，

 所以，扩充为0次。