【Java集合源码剖析】ArrayList源码剖析

之前看了一下《兰亭风雨》的集合源码分析，原地址为：http://blog.csdn.net/ns_code/article/details/35568011，发现和jdk1.8略微有点不同，因此参照他的博客格式，自己一点点的分析了一下jdk1.8的源码，然而发现1.8里添加了很多的方法，因此这里只写常用的，其实只要知道数据结构怎么变动的，其他的都是大同小异。

ArrayList简介

    ArrayList是基于数组实现的，是一个动态数组，其容量能自动增长，类似于C语言中的动态申请内存，动态增长内存。

    ArrayList不是线程安全的，只能用在单线程环境下，多线程环境下可以考虑用Collections.synchronizedList(List l)函数返回一个线程安全的ArrayList类，也可以使用concurrent并发包下的CopyOnWriteArrayList类。

    ArrayList实现了Serializable接口，因此它支持序列化，能够通过序列化传输，实现了RandomAccess接口，支持快速随机访问，实际上就是通过下标序号进行快速访问，实现了Cloneable接口，能被克隆。

ArrayList源码剖析

    ArrayList的源码如下（加入了比较详细的注释）：

package java.util;
public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    //序列版本号
private static final long serialVersionUID = 8683452581122892189L;
//默认ArrayList的容量
    private static final int DEFAULT_CAPACITY = 10;
    //空元素的数组，主义里面是Object类型的
    private static final Object[] EMPTY_ELEMENTDATA = {};
	//默认容量空元素的数组
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
	//ArrayList基于该数组实现，用该数组保存数据，里面元素是Object，瞬时的，非序列化
    transient Object[] elementData; // non-private to simplify nested class access
    //ArrayList中实际数据的数量
    private int size;

    //ArrayList带容量大小的构造函数
    public ArrayList(int initialCapacity) {
    //如果传入的容量大于0，就按要求建一个Object数组
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        //如果传入的容量等于0，返回一个空元素数组
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
		//如果传入的容量小雨0，返回一个非法参数异常
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }

    //创建一个空参构造函数，这个才是数组的元素为空
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

   //创建一个包含Collection的ArrayList
    public ArrayList(Collection<? extends E> c) {
	//先将集合元素转为数组，因为ArrayList维护的就是一个数组
        elementData = c.toArray();
		//如果里面的元素个数不为0，
        if ((size = elementData.length) != 0) {
            //看数组里的元素是不是Object，如果不是就转为Object
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            //如果里面元素为0个，那么直接一个空元素数组
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }
	//将集合的当前容量设为实际元素的个数
    public void trimToSize() {
        modCount++;
		//看实际个数是否小于容器的长度
        if (size < elementData.length) {
        //判断元素个数等于0？，如果等于直接返回空元素数组，否则copy一份指定大小的数组
            elementData = (size == 0)
              ? EMPTY_ELEMENTDATA
              : Arrays.copyOf(elementData, size);
        }
    }

 	//确认ArrayList的容量
    public void ensureCapacity(int minCapacity) {
        int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
            // any size if not default element table
            ? 0
            // larger than default for default empty table. It's already
            // supposed to be at default size.
            : DEFAULT_CAPACITY;

        if (minCapacity > minExpand) {
            ensureExplicitCapacity(minCapacity);
        }
    }
	//返回ArrayList里的元素个数
    public int size() {
        return size;
    }

    //判断ArrayList是否为空
    public boolean isEmpty() {
        return size == 0;
    }

 	//判断ArrayList是否包含某个元素（接受Object类型的）
    public boolean contains(Object o) {
	//其实就是调用了indexOf，如果没有找到，必然返回为false
        return indexOf(o) >= 0;
    }
	//正向查找，返回元素的索引值
    public int indexOf(Object o) {
	//把null单独提出来，因为null不能用equals方法判断
        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;
    }

 	//反向查找，从后往前查是否包含某个元素
    public int lastIndexOf(Object o) {
	//同理要把null单独拿出来判断
	//此外由于是数组，所以初始化坐标为size-1
        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;
    }

    //克隆函数
    public Object clone() {
        try {
            ArrayList<?> v = (ArrayList<?>) super.clone();
			//将当前ArrayList的全部元素拷贝到v中
            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(e);
        }
    }

    //返回ArrayList的Object数组
    public Object[] toArray() {
	就是用Arrays  copy了一份一模一样的
        return Arrays.copyOf(elementData, size);
    }

    //返回ArrayList元素组成的数组，这个返回的是泛型，不是Object数组
    public <T> T[] toArray(T[] a) {
	//如果数组a的大小 <  ArrayList的元素个数，则呈现建一个T[]数组，数组大小是ArrayList的元素个数，并将并将“ArrayList”全部拷贝到新数组中
        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;
    }

   	//获取index位置的元素值，返回是E
    public E get(int index) {
	//检查范围，其实就是看index>size不，如果大于就抛异常
        rangeCheck(index);
		
        return elementData(index);
    }

   //设置index位置的元素
    public E set(int index, E element) {
	//先检查一下范围
        rangeCheck(index);
		//先把老的值保存一下，用于返回
        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;
    }

   	//添加元素
    public boolean add(E e) {
	//先确认一下容量，使容量设置为size+1
        ensureCapacityInternal(size + 1);  // Increments modCount!!
		//将元素添加到ArrayList的末尾
        elementData[size++] = e;
        return true;
    }

   	//从某个元素位置开始添加元素
    public void add(int index, E element) {
	//先检查范围
        rangeCheckForAdd(index);
		//确认数组的容量
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        //arraycopy(Object src, int srcPos,Objectm dest,int destPos,int length)，从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结        //束。其实就是将从index开始到后面的数组向后移了一位
        System.arraycopy(elementData, index, elementData, index + 1,size - index);
        elementData[index] = element;
		//记得数据个数+1
        size++;
    }

   //删除ArrayList指定位置的元素
    public E remove(int index) {
        rangeCheck(index);
        modCount++;
        E oldValue = elementData(index);
	//确定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;
    }

    //删除ArrayList的指定元素
    public boolean remove(Object o) {
        if (o == null) {//先将null单独判断
            for (int index = 0; index < size; index++)
                if (elementData[index] == null) {
		//其实就是将找到的index后面的数据向前移
                    fastRemove(index);
                    return true;
                }
        } else {//遍历ArrayList，找到到指定的元素
            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
    }

    //清空ArrayList，将全部元素设为null
    public void clear() {
        modCount++;
        for (int i = 0; i < size; i++)
            elementData[i] = null;
	//size设为0
        size = 0;
    }

   //添加进一个集合
    public boolean addAll(Collection<? extends E> c) {
	//先将集合变为数组
        Object[] a = c.toArray();
        int numNew = a.length;//集合的长度
		//确认新ArrayList的数据个数
        ensureCapacityInternal(size + numNew);  // Increments modCount
        System.arraycopy(a, 0, elementData, size, numNew);
        size += numNew;
	//numNew == 0返回false，相当于没添加
        return numNew != 0;
    }

    //在指定位置添加一个结合，其实就是System.arraycopy，哪里第二个参数为index
    public boolean addAll(int index, Collection<? extends E> c) {
        rangeCheckForAdd(index);
        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacityInternal(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之间的全部元素
    protected void removeRange(int fromIndex, int toIndex) {
        modCount++;
        int numMoved = size - toIndex;
        System.arraycopy(elementData, toIndex, elementData, fromIndex,numMoved);
        // clear to let GC do its work
	//把后边空出来的位置设为null
        int newSize = size - (toIndex-fromIndex);
        for (int i = newSize; i < size; i++) {
            elementData[i] = null;
        }
        size = newSize;
    }
   	//范围检查，每次操作index时，都要检查一下，看是否超出元素个数范围，如果超过就直接抛异常，不用做下一步操作
    private void rangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }