浅析Java源码之ArrayList

　　面试题经常会问到LinkedList与ArrayList的区别，与其背网上的废话，不如直接撸源码！

　　文章源码来源于JRE1.8，java.util.ArrayList

　　既然是浅析，就主要针对该数据结构的内部实现原理和部分主要方法做解释，至于I/O以及高级特性就暂时略过。

变量/常量

　　首先来看定义的(静态)变量：

class ArrayList2<E>
    //extends AbstractList<E>
    //implements RandomAccess, Cloneable, java.io.Serializable
{
    private static final long serialVersionUID = 8683452581122892189L;
    private static final int DEFAULT_CAPACITY = 10;
    private static final Object[] EMPTY_ELEMENTDATA = {};
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    transient Object[] elementData;
    private int size;
}

　　这里在一开始定义了6个变量，其中第一个跟序列化相关不用管，其余5个依次解释一下：

DEFAULT_CAPACITY：代表容器ArrayList的初始化默认大小

Object[] EMPTY_ELEMENTDATA：一个空数组，在某些方法调用后(例如removeAll)会用到

Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA：默认空数组，未传参初始化时默认为这个

Object[] elementData：保存着当前ArrayList的内容，该变量被标记为序列化忽略对象

int size：很明显，当前ArrayList大小

　　需要注意的是，其中几个被标记为static final变量。

构造函数

　　看完变量，接下来看构造函数部分，构造函数有3个重载版本，分别阐述如下。

1、无参版本

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

　　如果不传任何参数直接初始化一个ArrayList，会得到上面默认的空数组。

2、int版本

    public ArrayList(int initialCapacity) {
        // 正常情况会初始化一个指定大小的数组
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        }
        // 传0在实现上与不传是一样的
        else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        }
        // 乱传就抛异常
        else {
            throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
        }
    }

　　这基本上最普遍的情况，可以看出内部实现就是普通的数组。

3、Collection版本

    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 {
            // 传空集合相当于空数组
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

　　如果初始化传入一个集合，会将此集合作为ArrayList的初值。

　　这里存在一个bug，即toArray方法返回的不一定是Object，虽然默认情况下是，但是如果被重写就不一定了。

　　详细问题可见另一位的博客：http://blog.csdn.net/gulu_gulu_jp/article/details/51457492

　　如果返回不是Object类型，会做向上转型。

方法

　　接下来看看常用的方法。

首先是get/set方法：

    public E get(int index) {
        rangeCheck(index);
        return elementData(index);
    }

    public E set(int index, E element) {
        rangeCheck(index);

        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;
    }

　　可以看出十分简单暴力，首先会进行范围检查，然后返回/设置对应index的元素。

　　简单看一下rangeCheck：

    private void rangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

　　也十分简单，主要是判断所给的索引index是否大于数组的大小size，否则抛出异常。

　　获取对应的值时，没有直接用elementData[index]，而是用了一个方法elementData()，看着有点混，看一下方法定义：

    E elementData(int index) {
        return (E) elementData[index];
    }

　　方法其实只是对取出来的值进行了类型转换，保证了返回类型的准确。

接下来是add/remove方法

　　这两个方法都有重载版本，但是并不复杂，而且都用的比较多。

　　首先看add的一个参数版本，会在尾部插入给定元素。

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

　　稍微讲下源码注释的modCount，这个变量来源于java.util.AbstractList，专门用来计算容器被改动的次数，对于我这种菜鸟使用者来说没啥用。

　　这里会首先检测下容器的容量，然后在尾部加入元素，并将size加1。

　　看看ensureCapacityInternal方法：

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

　　原来这是一个皮包函数，当数组元素为空时，会进行参数修正，由于容器的默认大小为10，所以不会对10以下的容量进行检测。

　　修正后，将10或者比10大的形参传入ensureExplicitCapacity进行检测：

    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

　　这看起来也像个皮包方法，不过并不是，如果当前容器大小已经达到上限，会调用grow进行扩容：

    private void grow(int minCapacity) {
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

　　其实这里的形参名字我觉得不是特别好，应该叫最小所需容量，即minNeededCapacity。

　　这里首先会获取当前容器大小，并进行扩容，这里的扩容是这样算的：

　　oldCapacity + (oldCapacity >> 1)

　　也就是如果之前为10，那么新容量为10 + Math.floor(10/2) = 15。

　　得到新容量后，会与传进来的 所需容量进行对比，如果还不够，那就干脆取所需容量为新容量。

　　第二个if是判断扩容后的容量是否大于最大(数组可达)整数，看下MAX_ARRAY_SIZE变量定义就明白了：

    /**
     * The maximum size of array to allocate.
     * Some VMs reserve some header words in an array.
     * Attempts to allocate larger arrays may result in
     * OutOfMemoryError: Requested array size exceeds VM limit
     */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

　　这里的注释有必要看一眼，简单讲就是有些JVM会在数组中加入一些东西，所以实际上数组大小是比理论上小一点的。这个很容易理解的，比如电脑硬盘，容量100G，可用容量其实会打个折扣，一个道理的。

　　为了完整，所以也看一下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;
    }

　　参数检测挺好玩，内部使用的函数还怕传入负数。

　　这里会将所需容量与最大可用安全容量作比较，如果实在没办法，就将容量设置为最大可用容量，至于这里会不会出问题我也不知道。

　　回到grow方法，得到新的容量后，会调用Arrays.copyOf方法，这个方法是包内另一个类的方法，内部实现是调用System.arraycopy直接进行内存复制，效率很高，最后返回一个新数组，size为加大后的容量。

　　

　　接下来看第二个重载的add方法：

    public void add(int index, E element) {
        rangeCheckForAdd(index);
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;
        size++;
    }

　　这里的检测不太一样，多了一步，不过看一眼方法就明白了：

    private void rangeCheckForAdd(int index) {
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

　　由于这个重载方法是插入，所以需要进行数值检测，如果插入索引大于数组大小或者小于0，抛个异常。

　　接下来是常规的容量检测。

　　下一步的方法就是之前提到的System.arraycopy，该方法会将索引+1后面的元素全部复制到源数组，举个简单的例子：

　　如果原数组为[1,2,3,4]，假设索引为1，经过这一步，数组会变为[1,2,2,3,4]。

　　最后是将对应索引的值赋为给定值，size++。

　　可以看出，在数组中间插入一个元素是非常耗时的，会变动索引后面的每一个数组元素。

　　接下来是remove，这个方法也有2个重载，一个是删除给定索引，一个是删除给定元素：

    public E remove(int index) {
        rangeCheck(index);
        modCount++;
        E oldValue = 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;
    }

　　没啥好讲的，忽略检测，一句话概括就是将对应索引-1的所有元素复制到原数组，然后size-1，并将末尾元素置null让GC进行回收，最后返回删除元素。

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

　　这个是第二个重载，对null进行了特殊处理，这个奇怪的东西只能用==来进行比较。

　　总体来讲就是遍历数组，如果找到了匹配元素，进行fastRemove，删除成功返回true，否则返回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很相似，只是移除了范围检测与返回值的处理，更快一些。

　　其余的方法大多数是上面的变种，没什么研究的必要了，有兴趣的可以自行阅读源码。