JDK 源码学习 -- ArrayList，LinkedList

本文从先分析了实现了List接口的几个常用集合类之间的关系和区别，然后再从代码层次分析这些区别和联系时如何实现的。

实现了List接口的类主要有：AbstractList, AbstractSequentialList, ArrayList, AttributeList, CopyOnWriteArrayList, LinkedList, RoleList, RoleUnresolvedList, Stack, Vector 

其中我们常用的有：Array List，LinkedList，Vector，Stack四个，他们有以下特点：

（1）ArrayList，Vector，Stack都是基于Object数组实现的，Stack更是直接继承了Vector类，完全使用了Vector的操作。

（2）LinkededList基于一个名为Node<E> 的内部类实现了一个双向链表。

（3）ArrayList和Vector如果在新建的时候没有指定size，那么在第一次添加元素的时候会设置一个默认DEFAULT_CAPACITY = 10.

（4）ArrayList在超出当前大小的时候，会自动扩容，扩大0.5倍，Vector也会扩容，如果没有指定每次扩大的数量，就扩充一倍。

（5）Vector是线程安全类型，所有共有方法都带有同步锁synchronized。

一，ArrayList源码阅读

ArrayList定义了一系列的Object[]，用来存放添加进来的元素。

/**
 * 共享的空数组，用来在清空或者对象为空的时候来赋值.
 */
private static final Object[] EMPTY_ELEMENTDATA = {};

/**
 * 共享的空数组，和EMPTY_ELEMENTDATA的区别是，如果创建了一个空的ArrayList对象，
 * 将用这个数组来标识，并且在第一次add元素的时候，可以使用这个对象来判断是否是第一次。
 */
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

/**
 * 存放元素的数组，它的长度就是ArrayList的长度，使用 DEFAULTCAPACITY_EMPTY_ELEMENTDATA
 * 标识的空ArrayList在第一次新增元素的时候将会扩展成 DEFAULT_CAPACITY 大小的对象
 * 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

在这些数组定义的上面，有一个默认元素个数的定义。

    /**
     * Default initial capacity.
     */
    private static final int DEFAULT_CAPACITY = 10;

最大支持的元素个数为：Integer.MAX_VALUE - 8，如果超过这个限制，将会报异常：OutOfMemoryError: Requested array size exceeds VM limit

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

再看ArrayList的构造器，ArrayList提供了三个构造器，无参的，带默认size的，使用其他Collection子类的。

/**
     * Constructs an empty list with the specified initial capacity.
     * 初始化成指定大小的Object数组
	 * 
     * @param  initialCapacity  the initial capacity of the list
     * @throws IllegalArgumentException if the specified initial capacity
     *         is negative
     */
    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);
        }
    }

    /**
     * Constructs an empty list with an initial capacity of ten.
     */
    public ArrayList() {
		/*
		 * 无参构造器，在新建的时候只是赋值了前面提到的默认数组
		 * 在第一次Add对象的时候才扩容到 DEFAULT_CAPACITY ，
		 * 实现懒汉型扩容，在用到的时候才扩充，尽量减少对堆内存的占用时间
		 */
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

    /**
     * Constructs a list containing the elements of the specified
     * collection, in the order they are returned by the collection's
     * iterator.
	 * 用于将其他集合类型转换成ArrayList
     *
     * @param c the collection whose elements are to be placed into this list
     * @throws NullPointerException if the specified collection is 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;
        }
    }

再来看add方法。

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

add方法首先调用 ensureCapacityInternal 方法检查size的情况，检查是否需要扩容，具体说明见代码中的注释。

private void ensureCapacityInternal(int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
	/*
	 * 如果是 DEFAULTCAPACITY_EMPTY_ELEMENTDATA对象，证明是使用无参构造器创建的对象，
	 * 并且是第一次新增元素，需要将Object 的数组大小扩充至 DEFAULT_CAPACITY
	*/
	minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}

最后一行的ensureExplicitCapacity 方法，调用了grow方法，在添加元素后的的数量大于当前数组的长度的时候，就需要扩容0.5倍的操作，grow方法的实现如下

/**
 * 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;
	/**
	 * oldCapacity + (oldCapacity >> 1) 实现了扩充0.5倍的操作，右移一位代表除以2操作。
	 * 使用 newCapacity *= 1.5 也能实现，但是显然 加法配合位移运算符速度比浮点数运算更快
	 */
	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);
}

再看remove方法，ArrayList可以按index删除，也可以按内容删除，按内容删除的时候，就是遍历整个Object数组，找到对应的index，然后进行删除。所以只看按index删除的这个方法。

public E remove(int index) {
	// 范围校验，我们常见的IndexOutOfBoundsException 异常就是这个方法抛出来的
	rangeCheck(index); 

	// 操作次数加 1
	modCount++;
	// 保存要删除的元素，最后返回这个元素
	E oldValue = elementData(index);

	// 需要移动的元素个数，使用 System.arraycopy将删掉元素的后面所有元素前移
	int numMoved = size - index - 1;
	if (numMoved > 0)
		System.arraycopy(elementData, index+1, elementData, index,
						 numMoved);
						 
	// 释放最后一个元素的引用，通知GC回收，这个很重要，否则造成内存泄露
	elementData[--size] = null; // clear to let GC do its work

	return oldValue;// 返回被删除的元素
}

最后再看看clear方法

public void clear() {
	modCount++;

	// clear to let GC do its work
	for (int i = 0; i < size; i++)
		elementData[i] = null;

	size = 0;
}

关注点只有一个，不能知将 size置为 0，必须将所有Object数组的引用置成null，这样GC在检查的时候才会回收掉这部分的堆内存。

另外ArrayList还支持批量删除，批量增加，按范围删除的方法，具体实现类似上面提到的基本方法，不再一一列出，用于对集合类型统一遍历的ListIterator以及Iterator这里也有实现，其中ListIterator支持边遍历边删除元素，正向反向遍历，感兴趣的读者请参阅作者前面的博客。

自从JDK1.8以来Java增加了对并行操作的支持，新增了Spliterator接口，所有集合类型都默认实现了这个接口，ArrayList的实现是ArrayListSpliterator，顾名思义，就是将一个ArrayList分割成不同的迭代器进行遍历，具体怎么用还在探索当中，参考这位大牛的博客：http://blog.csdn.net/lh513828570/article/details/56673804 

二，LinkedList 源码阅读

LinkedList 与ArrayList不同，LinkedList底层使用内部类Node维护了一个双向链表，所以没有size的限制，也不需要扩容，每次新增的时候直接new一个Node新增进去既可以。

LinkedList只配置了三个全局变量，size用于统计当前元素总数，first，last分别标识链表的开头和结尾。

transient int size = 0;

    /**
     * Pointer to first node.
     * Invariant: (first == null && last == null) ||
     *            (first.prev == null && first.item != null)
     */
    transient Node<E> first;

    /**
     * Pointer to last node.
     * Invariant: (first == null && last == null) ||
     *            (last.next == null && last.item != null)
     */
    transient Node<E> last;

内部类Node

private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }

具体实现都是简单的双向链表操作，这里不再一一列出，JDK为我们封装了繁琐，复杂的底层实现，让我们将精力都放在了业务实现上面。

总结：

JDK代码是Java的精髓，也是我们学习的宝贵资源，今日的学习有以下总结，收获。

（1）JDK 都是使用懒加载，快销毁，尽量减少对象占用内存的时间。比如，ArrayList的默认扩容操作，第一次添加元素的时候才进行扩容，而不是现金ArrayList对象的时候就增加容量，而一旦删除了某个元素，将会立即将这个元素的引用释放掉。

（2）JDK源码中一般很少出现单独的赋值语句，一般在赋值操作后都会检查结果，JDK都是一步完成的，比如：

if ((c = x.getClass()) == String.class) // bypass checks

这一行即完成了赋值，又完成了对变量的判断丝毫没有浪费。这样做还有一个好处，当需要判断多个变量的时候，只有前面的变量赋值成功并且通过校验之后才会进行下一个下一个变量的计算，赋值动作，而不是将好几个变量先计算完毕，再校验，万一第一个变量就是不合格的，这样后面n个变量的计算就都是无用的操作了。