Java集合源码分析1：JDK1.8源码分析之ArrayList

前言

在了解集合框架的源码之前应要先了解其底层的数据结构、了解其特点和源码中的属性及其作用。
ArrayList集合的底层数据结构是数组，数组元素类型为Object类型，即可以存放所有类型数据。

ArrayList集合框架的特点

ArrayList集合框架源码中类的属性

属性	作用
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	实际数组中元素的个数，默认为0
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8	最大数组容量

其属性对应的源码如下：

public class ArrayList extends AbstractList
        implements List, RandomAccess, Cloneable, java.io.Serializable
{
    private static final long serialVersionUID = 8683452581122892189L;

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

    /**
     * Shared empty array instance used for empty instances.
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};

    /**
     * Shared empty array instance used for default sized empty instances. We
     * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
     * first element is added.
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

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

    /**
     * The size of the ArrayList (the number of elements it contains).
     *
     * @serial
     */
    private int 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;
    
    ｝

说明：类的属性中核心的属性为elementData，类型为Object[]，用于存放实际元素，并且被标记为transient，也就意味着在序列化的时候，此字段是不会被序列化的。

ArrayList类的继承关系

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

ArrayList类继承AbstractList抽象父类，实现了List接口（规定了List的操作规范）、RandomAccess（可随机访问）、Cloneable（可拷贝）、Serializable（可序列化）。

（1）RandomAccess接口源码：

public interface RandomAccess {
}

（2）Cloneable接口源码：

public interface Cloneable {
}

（3）Serializable接口源码：

public interface Serializable {
}

由此可知RandomAccess、Cloneable、Serializable知识一种规范表名该类具有什么样的功能。

ArrayList类的构造函数

（1）带参构造函数（public ArrayList(int initialCapacity)）

public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {	// 初始化容量大于0
            this.elementData = new Object[initialCapacity];	// 初始化数组
        } else if (initialCapacity == 0) {	// 初始化容量等于0
            this.elementData = EMPTY_ELEMENTDATA;	// 初始化为空对象数组
        } else { // 初始化容量小于0抛出异常信息
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }

说明：当initialCapacity大于0时，指定初始化长度为initialCapacity的数组；当initialCapacity等于0时，指定空对象数组；当initialCapacity小于0时抛出不合法的容量异常。

（2）无参构造函数（public ArrayList() ）

public ArrayList() {
		// 无参构造函数，设置元素数组为空 
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

说明：当实例化对象时未指定数组的长度，默认初始化为空对象数组。
（3）带参构造函数（public ArrayList(Collection c)）

public ArrayList(Collection 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;
        }
    }

说明：此构造函数的参数为集合类型，首相将集合参数转化为数组并赋值给elementData数组。若此数组长度为0，则将elementData赋值为空数组集合；若此数组长度大于0并且elementData和Object[]不为同一个类对象，则执行 Arrays.copyOf(elementData, size, Object[].class)。
Object.class、Object[].class等的区别：

package xiao;
import java.util.ArrayList;
import java.util.List;

public class Test {
	public static void main(String[] args) {
		Object[] ob = new Object[10];
		Object b = 0;
		System.out.println(ob.getClass() + "\t" + b.getClass());
		System.out.println(Object.class + "\t" + Object[].class);
	}
}

由以上运行结果分析可知：

• 当父类引用指向子类对象时，类对象为子类的类对象。
• Object和Object[]的类对象是不同的。

ArrayList类中方法源码分析

（1）add() 方法：向集合中添加元素

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

说明：ensureCapacityInternal(size + 1)这个方法是为了elementData数组有适当的大小，可对elementData进行扩容。

ensureCapacityInternal(size + 1)源码如下：

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

        ensureExplicitCapacity(minCapacity);
    }

说明：若elementData为空数组则则将该数组初始化为默认长度的数组。具体的扩容函数是在ensureExplicitCapacity(minCapacity)方法中调用的，其源码如下：

private void ensureExplicitCapacity(int minCapacity) {
	 // 结构性修改加1
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

说明：此方法才真正的确保elementData数组有适当的大小。首先需要判断元素参入的位置是否超过了数组的长度，如果超过了数组的长度则调用grow方法进行扩容处理。

grow()方法源码如下：

private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        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);
    }

说明：首先将为新容量进行赋值且为旧容量的1.5倍，然后新容量赋值为新容量和minCapacity的最大者。此外特殊情况下（新扩展数组大小已经达到了最大值）则只取最大值。最后一步进行拷贝扩容处理。
（2）set(int index, E element)方法：修改指定位置处的元素值

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

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

说明：首先用rangeCheck(index)方法判断索引是否合法，如果不合法将会抛出异常信息，其源码如下：

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

如果索引合法首先取出索引处的元素用作返回值，并给索引处赋新值。
（3）indexOf(Object o)方法：查找形参元素在集合中第一次出现的位置

 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元素进行空和非空判断， 并遍历数组，找到第一个和指定元素相等的元素，返回下标。如果o元素在集合中不存相等的元素在则返回-1。
（4）get(int index)方法：获取集合在index下标下的元素值

public E get(int index) {
        rangeCheck(index);

        return elementData(index);
    }

说明：首先进行索引是否合法判断，然后调用elementData()函数：

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

集合中index处的元素作为返回值，并进行了向下转型。
（5）E remove(int index)：删除指定索引处的元素值

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);
        // 赋值为空，有利于进行GC
        elementData[--size] = null; 
        // 返回旧值
        return oldValue;
    }