ArrayList源码解析

来一道面试题：

ArrayList<Integer> list = new ArrayList<>();
list.add(5);
list.add(4);
list.add(3);
list.add(2);
list.add(1);
list.remove(1);
list.remove((Integer)2);

list中，还剩下哪几个元素？

 

带着这个问题，来看一下ArrayList的源码。

ArrayList构造器总共有三种：

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


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


    public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

分别是无参构造器，设置初始化数组长度的构造器和可以设置初始化集合的构造器。

一般使用的都是无参构造器，看一下无参构造器里面elementData和DEFAULTCAPACITY_EMPTY_ELEMENTDATA分别是什么：

    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};


    transient Object[] elementData; // non-private to simplify nested class access

DEFAULTCAPACITY_EMPTY_ELEMENTDATA是final类型的静态参数，使用static修饰，代表了如果创建多个ArrayList时，可以复用DEFAULTCAPACITY_EMPTY_ELEMENTDATA。值得注意的是，这里初始化时，elementData的初始大小是0。

elementData就是一个普通的Object数组，它就是ArrayList的底层实现。

继续看一下add方法：

    private int size;    
    private static final int DEFAULT_CAPACITY = 10;

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

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

        ensureExplicitCapacity(minCapacity);
    }

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

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

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

ensureCapacityInternal是对数组进行扩容，保证当前的数组长度，装的下目前的数据。

可以看到ensureCapacityInternal先判断elementData是否是DEFAULTCAPACITY_EMPTY_ELEMENTDATA，如果是的话将取DEFAULT_CAPACITY和minCapacity的最大值作为数组的最小容量。size初始化时为0， 那么传入的形参minCapacity=1。DEFAULT_CAPACITY初始化为10，所以计算以后的minCapacity为10。

再看ensureCapacityInternal函数，modCount记录的是ArrayList的修改次数，贯穿于整个ArrayList源码当中。然后将当前的数组长度与最小的可用容量作对比，如果数组长度不大于最小容量，就会使用grow函数对elementData进行扩容。

grow里，oldCapacity记录了数组长度的原始值，大小是0。newCapacity是oldCapacity的1.5倍，这时也是0。也就是ArrayList每次进行扩容，都会将数组扩大1.5倍。这里形参minCapacity=10。会走进入到第一个判断条件里，将newCapacity赋值为10.

最后使用Arrays.copyOf方法，对elementData进行复制和扩容。Arrays.copyOf方法底层使用c/c++实现，效率比java代码用for循环实现数组的复制要高很多，所以在遇到数组拷贝和扩容的时候，应当优先使用Arrays.copyOf方法。

回到add函数里，ensureCapacityInternal对数组扩容后，保证了数组大小可以装的下新进来的数据，再将新数据放在数组第一个空闲位上，并返回true；

为了回答文章开始的问题，还需要看一下remove函数，remove有两个重载的实现方法：

   public E remove(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));

        modCount++;
        E oldValue = (E) elementData[index];

        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // clear to let GC do its work

        return oldValue;
    }


    public boolean remove(Object o) {
        if (o == null) {
            for (int index = 0; index < size; index++)
                if (elementData[index] == null) {
                    fastRemove(index);
                    return true;
                }
        } else {
            for (int index = 0; index < size; index++)
                if (o.equals(elementData[index])) {
                    fastRemove(index);
                    return true;
                }
        }
        return false;
    }

    private void fastRemove(int index) {
        modCount++;
        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // clear to let GC do its work
    }

第一个remove方法接收int类型的指针，方法实现也很简单。第8、9行可以看出，若移除的元素不是最后一个元素，会将数组中移除元素位置后面的元素向前移动一位（即下面fastRemove函数的作用）。

第二个remove方法接收Object类型的参数。若传入的对象为空，会移除当前数组中的null元素，并将后面的元素依次向前移动一位。若传入的对象非空，会查找数组中的元素是否与传入的Object相同，同样做fastRemove操作。

看到这里，文章开头的问题已经有了答案。

list.remove(1);
list.remove((Integer)2);

共调用了两次remove函数，第一个remove函数传入的类型是int类型，也就是按索引移除第2个元素（数组下标从0开始），第2个元素的值是4。第二个remove函数传入的Integer类型，是Object的子类型，会移除列表里值为2的元素。

这样，列表里还剩下5,3,1三个元素。