ArrayList源码分析

　　首先，来看ArrayList的定义：

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

ArrayList继承于AbstractList类，并实现了List、RandomAccess、Cloneable和Serializable接口。

    /**
     * 定义ArrayList内部保存数据用的数组。
     */
    private transient Object[] elementData;

    /**
     * 定义ArrayList的实际包含数据的长度。
     */
    private int size;

看构造方法：

    /**
     * 根据传入的initialCapacity来定义一个数组。如果initialCapacity小于0，则抛出IllegalArgument异常。
     */
    public ArrayList(int initialCapacity) {
    super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
    this.elementData = new Object[initialCapacity];
    }

    /**
     * 默认创建一个长度为10的Object类型数组。
     */
    public ArrayList() {
    this(10);
    }
    
     /**
     * 根据传入的集合来初始化。如果传入的集合的toArray()方法返回的不是Object[]类型的，则利用Arrays.copyOf来转为Object[]类型
     */
    public ArrayList(Collection<? extends E> c) {
    elementData = c.toArray();
    size = elementData.length;
    // c.toArray might (incorrectly) not return Object[] (see 6260652)
    if (elementData.getClass() != Object[].class)
        elementData = Arrays.copyOf(elementData, size, Object[].class);
    }

注意第3个构造方法当中有一个注释：c.toArray might (incorrectly) not return Object[] (see 6260652)，意识是说c.toArray不一定总是返回Object[]类型的数组，这是incorrectly的，大家可以参照

http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6260652来看看这个java的bug。

下面开始分析ArrayList的各个方法：

①、trimToSize()

    /**
     * 此方法将数组elementData中没有用来存储数据的内存释放出来，减少占用的内存空间。
     * 使得list的size和capacity大小一样。
     */
    public void trimToSize() {
    modCount++;
    int oldCapacity = elementData.length;
    if (size < oldCapacity) {
            elementData = Arrays.copyOf(elementData, size);
    }
    }

②、ensureCapacity()

    /**
     * 数组扩容用的方法。如果传入的minCapacity还没有以前的容量大，则什么都不做；如果比以前的容量大，那也不一定就按照minCapacity的大小来扩容。
     * 首先，将以前的容量扩大到1.5倍再加上1，如果扩大后的容量比minCapacity小，则容量最终还是扩大到minCapacity，否则就扩大到以前的1.5倍加上1的大小。
     * 也就是说，扩容至少扩大到以前的1.5倍再加上1。
     */
    public void ensureCapacity(int minCapacity) {
    modCount++;
    int oldCapacity = elementData.length;
    if (minCapacity > oldCapacity) {
        Object oldData[] = elementData;
        int newCapacity = (oldCapacity * 3)/2 + 1;
            if (newCapacity < minCapacity)
        newCapacity = minCapacity;
            // minCapacity is usually close to size, so this is a win:
            elementData = Arrays.copyOf(elementData, newCapacity);
    }
    }

③、size()和isEmpty()

    /**
     * 返回list的大小，注意不是数组的容量大小。
     */
    public int size() {
    return size;
    }

    /**
     * 根据list的大小是否为0来判断list是否为空
     */
    public boolean isEmpty() {
    return size == 0;
    }

④、indexOf()和lastIndexOf()

    /**
     * 从数组下标0开始查找o，找到的话就返回其下标，如果没有找到，则返回-1。
     */
    public int indexOf(Object o) {
    if (o == null) {
        for (int i = 0; i < size; i++)
        if (elementData[i]==null)
            return i;
    } else {
        for (int i = 0; i < size; i++)
        if (o.equals(elementData[i]))
            return i;
    }
    return -1;
    }

    /**
     * 从数组最后一位开始向前查找o，找到的话返回其下标，否则返回-1。
     */
    public int lastIndexOf(Object o) {
    if (o == null) {
        for (int i = size-1; i >= 0; i--)
        if (elementData[i]==null)
            return i;
    } else {
        for (int i = size-1; i >= 0; i--)
        if (o.equals(elementData[i]))
            return i;
    }
    return -1;
    }

⑤、contains()

    /**
     * 调用indexOf方法来判断o是否存在于list中。
     */
    public boolean contains(Object o) {
    return indexOf(o) >= 0;
    }

⑥、clone()

    /**
     * 此方法为浅层复制，不是深层复制
     */
    public Object clone() {
    try {
        ArrayList<E> v = (ArrayList<E>) super.clone();
        v.elementData = Arrays.copyOf(elementData, size);
        v.modCount = 0;
        return v;
    } catch (CloneNotSupportedException e) {
        // this shouldn't happen, since we are Cloneable
        throw new InternalError();
    }
    }

⑦、toArray()和toArray(T[] a)

    /**
     * 将list转为数组，注意是重新创建了一个长度相同（为size）的数组，与list内部的数组不是同一个
     */
    public Object[] toArray() {
        return Arrays.copyOf(elementData, size);
    }

    /**
     * 将list转为数组，数组的类型由传入的参数a决定。
     * 如果a的长度小于list的长度，则从list的第一个元素开始直至填满a；
     * 如果a的长度大于list的长度，则把list的元素全部填入a后，将a[a.length]设为null。
     */
    public <T> T[] toArray(T[] a) {
        if (a.length < size)
            // Make a new array of a's runtime type, but my contents:
            return (T[]) Arrays.copyOf(elementData, size, a.getClass());
    System.arraycopy(elementData, 0, a, 0, size);
        if (a.length > size)
            a[size] = null;
        return a;
    }

⑧、RangeCheck()

    /**
     * 此方法为判断index是否超出list的长度size，注意不是list的容量。
     * 如果超出，则抛出IndexOutOfBounds异常。
     * list的很多方法都会先调用此方法来做判断。
     */
    private void RangeCheck(int index) {
    if (index >= size)
        throw new IndexOutOfBoundsException(
        "Index: "+index+", Size: "+size);
    }

接下来的是一些访问list的方法：

    /**
     * 首先调用RangeCheck方法判断index合法性，然后直接返回数组对应下标的值。
     */
    public E get(int index) {
    RangeCheck(index);

    return (E) elementData[index];
    }

    /**
     * 首先调用RangeCheck方法判断index的合法性，然后定义一个变量oldValue指向数组对应下标的值，
     * 再将此下标的值换为传入的参数element，最后返回旧的值oldValue。
     */
    public E set(int index, E element) {
    RangeCheck(index);

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

    /**
     * 此方法为往list的下标为size的地方添加元素e。
     * 首先对数组进行扩容，然后将数组下标为size的元素赋为e。
     */
    public boolean add(E e) {
    ensureCapacity(size + 1);  // Increments modCount!!
    elementData[size++] = e;   // 这种写法一举两得，既赋了值，又把size加了1，可以省下一行代码。
    return true;
    }

    /**
     * 此方法为在指定下标处添加元素。
     * 首先判断传入的index是否合法，注意index可以等于size，这时应该相当于前面的add(E e)方法。
     * 然后也是先把数组扩容，接着通过System的arraycopy方法把数组从下表index开始到size-1处的元素整体往后移一位。
     */
    public void add(int index, E element) {
    if (index > size || index < 0)
        throw new IndexOutOfBoundsException(
        "Index: "+index+", Size: "+size);

    ensureCapacity(size+1);  // Increments modCount!!
    System.arraycopy(elementData, index, elementData, index + 1,
             size - index);
    elementData[index] = element;
    size++;
    }

    /**
     * 此方法为删除指定下标处的元素。
     * 首先判断index的合法性。然后定义一个变量oldValue获取数组指定下标处的元素。
     * 然后定义numMoved变量获取（size - index - 1）的值，如果为0，则表示index为list的最后一个元素的下标，那么就木有必要再进行数组元素的移动了。
     * 否则index不是最后一个元素的下标，那么把数组里的下标为index+1的元素开始到最后一个元素全部往前移动一位。
     * 再将list的最后一位赋值为null，同时将size减少1。
     * 最后返回oldValue，即被删除的元素。
     */
    public E remove(int index) {
    RangeCheck(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; // Let gc do its work

    return oldValue;
    }

    /**
     * 删除数组里第一个值为o的元素。
     * 先判断o是否为null，如果是null，则遍历数组，发现null的话，删除null，并返回true；
     * 如果不是null，则遍历数组，调用o的equals方法一次和数组元素进行比较，如果为true则删除此元素并返回true。
     */
    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;
    }

    /*
     * 私有的删除方法，与remove方法有两点区别：①不会返回被删除的元素；②不会调用RangeCheck方法进行check。
     */
    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; // Let gc do its work
    }

    /**
     * 此方法是清空list，遍历数组，将里面所有的元素都赋值为null。同时，size也赋值为0。
     */
    public void clear() {
    modCount++;

    // Let gc do its work
    for (int i = 0; i < size; i++)
        elementData[i] = null;

    size = 0;
    }

    /**
     * Appends all of the elements in the specified collection to the end of
     * this list, in the order that they are returned by the
     * specified collection's Iterator.  The behavior of this operation is
     * undefined if the specified collection is modified while the operation
     * is in progress.  (This implies that the behavior of this call is
     * undefined if the specified collection is this list, and this
     * list is nonempty.)
     *
     * @param c collection containing elements to be added to this list
     * @return <tt>true</tt> if this list changed as a result of the call
     * @throws NullPointerException if the specified collection is null
     */
    public boolean addAll(Collection<? extends E> c) {
    Object[] a = c.toArray();
        int numNew = a.length;
    ensureCapacity(size + numNew);  // Increments modCount
        System.arraycopy(a, 0, elementData, size, numNew);
        size += numNew;
    return numNew != 0;
    }

    /**
     * 把此方法传入的集合c依次从list的下标index开始添加，同时把原先下标index往后的所有元素再往后移动c.size()位。
     */
    public boolean addAll(int index, Collection<? extends E> c) {
    if (index > size || index < 0)
        throw new IndexOutOfBoundsException(
        "Index: " + index + ", Size: " + size);

    Object[] a = c.toArray();
    int numNew = a.length;
    ensureCapacity(size + numNew);  // Increments modCount

    int numMoved = size - index;
    if (numMoved > 0)
        System.arraycopy(elementData, index, elementData, index + numNew,
                 numMoved);

        System.arraycopy(a, 0, elementData, index, numNew);
    size += numNew;
    return numNew != 0;
    }

    /**
     * 删除下标从fromIndex到toIndex-1的元素。
     * 首先将下标从toIndex到size-1的元素全部向前移动size-toIndex位，
     * 然后将list的后toIndex-fromIndex位的元素的值赋为null。
     */
    protected void removeRange(int fromIndex, int toIndex) {
    modCount++;
    int numMoved = size - toIndex;
        System.arraycopy(elementData, toIndex, elementData, fromIndex,
                         numMoved);

    // Let gc do its work
    int newSize = size - (toIndex-fromIndex);
    while (size != newSize)
        elementData[--size] = null;
    }

最后，还有两个方法是序列化时处理用的：

    /**
     * 序列化时，先执行defaultWriteObject()方法；然后再把数组的长度也写入流中，最后分别把数组中的每个元素都写到流中。
     */
    private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException{
    // Write out element count, and any hidden stuff
    int expectedModCount = modCount;
    s.defaultWriteObject();

        // Write out array length
        s.writeInt(elementData.length);

    // Write out all elements in the proper order.
    for (int i=0; i<size; i++)
            s.writeObject(elementData[i]);

    if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }

    }

    /**
     * 从流中读取元素，先调用defaultReadObject()方法，然后依次读取数组长度，接着是数组当中的每个元素信息。
     * 和writeObject的写入顺序一样。
     */
    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
    // Read in size, and any hidden stuff
    s.defaultReadObject();

        // Read in array length and allocate array
        int arrayLength = s.readInt();
        Object[] a = elementData = new Object[arrayLength];

    // Read in all elements in the proper order.
    for (int i=0; i<size; i++)
            a[i] = s.readObject();
    }

终于看完了，其实ArrayList的父类AbstractList中还有很多重要的实现，不过下回分解吧。