ArrayList源码解读

List 接口继承于 Collection 接口，Collection 接口定义了一些基本的方法：

List 接口继承于 Collection 接口，是有序可重复集合，可以精确控制元素的插入、删除。与 Collection 接口相比又增加一些方法，下图为List接口中的方法：

AbstractList 抽象类实现了 List 接口的部分方法，这些方法都是基于 listIterator() 方法遍历实现的，如 indexOf() 和 lastIndexOf() 分别是向后和向前遍历比较；clear() 是遍历移除；equals() 是先判断是否相等，然后遍历比较。

在 AbstractList 中还有两个内部类（ listIterator() 方法就是利用其中一个内部类 ListItr 的实例实现的）：

1. Itr (implements Iterator<E>)，有基本的迭代方法 hasNext()、next()、remove()，其中 next() 是利用 get() 实现，get() 需要被其子类实现才可用；remove() 是利用 AbstractList.this.remove() 方法，remove() 同样需要被子类实现才可用。
2. ListItr (extends Itr implements ListIterator<E>)，继承自 Itr，增加了向前迭代方法和 add()、set()方法，方式与 Itr 类似，其实现仍依赖于实现类。

 以上是 List 接口和 AbstractList 抽象类的内容，下面我们重点来看一下 List 的实现类ArrayList。

ArrayList集合使用数组来完成存储数据，我们先看几个重要属性：

    /**
     * Default initial capacity.  默认初始容量10
     */
    private static final int DEFAULT_CAPACITY = 10;

    /**
     * 空数组
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};

    /**
     * 使用无参数构造方法创建集合对象时
     * 使用的空数组
     * 添加元素时，判断空数组对象是该对象时，分配默认初始容量为10
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    /**
     * 集合底层存储数据的数组对象
     */
    transient Object[] elementData; // non-private to simplify nested class access

    /**
     * 标识集合的元素个数 即：集合的大小size
     */
    private int size;

构造方法

1、public ArrayList(int initialCapacity)

    /**
     * 创建一个空的集合，初始容量为设置数组的初始大小
     * @param  initialCapacity 集合的初始容量
     * @throws IllegalArgumentException if the specified initial capacity
     *         is negative
     */
    public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {  //初始容量>0  创建一个初始容量大小的数组
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) { //初始容量为0  使用空数组EMPTY_ELEMENTDATA
            this.elementData = EMPTY_ELEMENTDATA;
        } else { //初始容量负数  抛出非法初始容量异常
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }

2、public ArrayList()

    /**
     * Constructs an empty list with an initial capacity of ten.
     * 创建一个空的集合，使用DEFAULTCAPACITY_EMPTY_ELEMENTDATA 数组
     * 添加元素时，开辟初始容量为10的数组
     */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

3、public ArrayList(Collection<? extends E> c)

   /**
     * Constructs a list containing the elements of the specified
     * collection, in the order they are returned by the collection's
     * iterator.
        构造一个包含指定 collection 的元素的列表，
        这些元素是按照该 collection 的迭代器返回它们的顺序排列的。
     *
     * @param c   
            其元素将放置在此列表中的 collection  
     * @throws NullPointerException if the specified collection is null
            如果指定的 collection 为 null 抛出空指针异常    
     */
    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;
        }
    }

重点理解的功能方法

1、 添加元素

//添加元素方法
    public boolean add(E e) {
        // 根据所需大小计算
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

//精确位置插入元素方法
    public void add(int index, E element) {
        // 判断 index 是否合法
        rangeCheckForAdd(index);
        // 根据所需大小计算
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        // 调整元素位置，将要插入的位置空出
        System.arraycopy(elementData, index, elementData, index + 1, size - index);
        elementData[index] = element;
        size++;
    }

//确定内部容量方法
    private void ensureCapacityInternal(int minCapacity) {
        // 如果数组为空，取默认大小和所需大小两者中较大的值
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        ensureExplicitCapacity(minCapacity);
    }

//确定扩充容量方法
    private void ensureExplicitCapacity(int minCapacity) {
        // 修改次数+1
        modCount++;
        // 判断是否需要扩充数组
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

//扩展容量方法
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        // 将数组容量扩大1.5倍
        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);
    }

//大容量设置 
    private static int hugeCapacity(int minCapacity) {
        // 小于0表示整型溢出
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
    }

2、移除元素

// 移除某个位置上的元素
    public E remove(int index) {
        // 检查删除位置是否合法
        rangeCheck(index);
        // 修改次数+1
        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;
    }
 // 移除某个元素
    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
    }