【Java集合源码】ArrayList

本文参考 JDK 版本为1.8
参考文章：https://github.com/Snailclimb/JavaGuide/blob/master/Java相关/ArrayList-Grow.md

ArrayList 简介

1. ArrayList 是基于数组实现的，是一个动态数组，其容量能自动增长；它继承于 AbstractList，实现了 List，RandomAccess，Cloneable，java.io.Serializable 这些接口。
2. ArrayList 继承了 AbstractList，实现了 List。它是一个数组队列，提供了相关的添加、删除、修改、遍历等功能。
3. ArrayList 实现了 RandmoAccess 接口，即提供了随机访问功能。RandmoAccess 是 java 中用来被 List 实现，为 List 提供快速访问功能的。在 ArrayList 中，我们即可以通过元素的序号快速获取元素对象，这就是快速随机访问。
4. ArrayList 实现了 Cloneable 接口，即覆盖了函数 clone() ，能被克隆。
5. ArrayList 实现 java.io.Serializable 接口，这意味着 ArrayList 支持序列化，能通过序列化去传输。

ArrayList 常量

/**
 * 序列版本号
 */
private static final long serialVersionUID = 8683452581122892189L;
/**
 * 默认初始容量
 */
private static final int DEFAULT_CAPACITY = 10;
/**
 * 指定该ArrayList容量为0时，返回该空数组。
 */
private static final Object[] EMPTY_ELEMENTDATA = {};
/**
 * 当调用无参构造方法，返回的是该数组。刚创建一个ArrayList 时，其内数据量为0。
 * 它与EMPTY_ELEMENTDATA的区别就是：该数组是默认返回的，而后者是在用户指定容量为0时返回。
 */
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
/**
 * 保存添加到ArrayList中的元素。
 * ArrayList的容量就是该数组的长度。
 * 该值为DEFAULTCAPACITY_EMPTY_ELEMENTDATA 时，当第一次添加元素进入ArrayList中时，数组将扩容值DEFAULT_CAPACITY。
 * 被标记为transient，在对象被序列化的时候不会被序列化。
 */
transient Object[] elementData; // non-private to simplify nested class access
/**
 * ArrayList的大小（它包含的元素数）
 */
private int size;

ArrayList 构造函数

1. 默认构造函数

/**
 * 默认构造函数
 * 构造一个初始容量为 10 的空列表
 * 创建 ArrayList 时，实际上初始化赋值的是一个空数组。当真正对数组进行添加元素操作时，才真正分配容量。即向数组中添加第一个元素时，数组容量扩为 10
 * Constructs an empty list with an initial capacity of ten.
 */
public ArrayList() {
	this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

源码注释的翻译是：构造一个初始容量为10的空列表。( Constructs an empty list with an initial capacity of ten.) 但是，却没有在默认构造函数中找到赋值容量为 10 的代码，当看到add方法时才知道： 无参数构造方法创建 ArrayList 时，实际上初始化赋值的是一个空数组。当真正对数组进行添加元素操作时，才真正分配容量。即向数组中添加第一个元素时，数组容量扩为 10

2. 带初始容量参数的构造函数

/**
 * 带初始容量参数的构造函数（自己指定容量）
 * Constructs an empty list with the specified initial capacity.
 */
public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) {	//初始容量大于0
    	 //创建initialCapacity大小的数组
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {	//初始容量等于0
    	 //创建空数组
        this.elementData = EMPTY_ELEMENTDATA;
    } else {	//初始容量小于0，抛出异常
        throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
    }
}

源码注释的翻译是：构造具有指定初始容量的空列表。(Constructs an empty list with the specified initial capacity.)可以看到当我们定义初始容量是 0 时，返回的是常量 EMPTY_ELEMENTDATA

3. 构造包含指定collection元素的列表

/**
 * 构造包含指定collection元素的列表，这些元素利用该集合的迭代器按顺序返回
 * 如果指定的集合为null，throws NullPointerException
 */
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;
    }
}

ArrayList 扩容机制

1. add() 方法

/**
 * 将指定的元素追加到此列表的末尾。 
 */
public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

从方法中可以看出，add 方法是将制定元素追加到此列表到末尾，并且在添加元素之前，先调用 ensureCapacityInternal 方法。

2. ensureCapacityInternal() 方法

private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
private static int calculateCapacity(Object[] elementData, int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}

在 ensureCapacityInternal 方法中，又先调用了 calculateCapacity 方法，计算容量。当是使用默认构造方法创建的 ArrayList 实例时，要 add 进第 1 个元素时，minCapacity 为 1，在 Math.max() 方法比较后，minCapacity 为 10。反之则返回 size + 1 的容量。

3. ensureExplicitCapacity() 方法

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

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

ensureExplicitCapacity 方法是判断是否需要扩容的，分析如下（针对使用 默认构造方法）：

• 当要 add 进第一个元素到 ArrayList 时，elementData.length 为 0（此时还是一个空的 list）执行了 ensureCapacityInternal() 方法后，minCapacity 为 10。此时： minCapacity - elementData.length > 0 成立 ，所以会进入 grow(minCapacity) 方法。
• 当 add 第二个元素时，minCapacity 为 2，elementData.length 在添加第一个元素后扩容成 10 了。此时： minCapacity - elementData.length > 0 不成立 所以不会执行 grow() 方法。
• 添加第3、4···到第 10 个元素时，依然不会执行 grow 方法，数组容量都为 10。直到添加第 11 个元素，minCapacity（为 11）比 elementData.length（为10）要大。进入 grow() 方法进行扩容。

4. grow() 方法

/**
 * ArrayList扩容的核心方法。
 */
private void grow(int minCapacity) {
    // overflow-conscious code
    // oldCapacity为旧容量，newCapacity为新容量
    int oldCapacity = elementData.length;
    //将oldCapacity 右移一位，其效果相当于oldCapacity / 2，
    //我们知道位运算的速度远远快于整除运算，整句运算式的结果就是将新容量更新为旧容量的1.5倍，
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    //然后检查新容量是否大于最小需要容量，若还是小于最小需要容量，那么就把最小需要容量当作数组的新容量，
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    //如果新容量大于 MAX_ARRAY_SIZE,进入(执行) 'hugeCapacity()' 方法来比较 minCapacity 和 MAX_ARRAY_SIZE，
    //如果minCapacity大于最大容量，则新容量则为'Integer.MAX_VALUE'，否则，新容量大小则为 MAX_ARRAY_SIZE 即为 `Integer.MAX_VALUE - 8`。
    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);
}

int newCapacity = oldCapacity + (oldCapacity >> 1)，所以 ArrayList 每次扩容之后容量都会变为原来的 1.5 倍 !
“>>”（移位运算符）：>>1 右移一位相当于除 2，右移 n 位相当于除以 2 的 n 次方
分析如下：

• 当 add 第 1 个元素时，oldCapacity 为 0，则 int newCapacity = oldCapacity + (oldCapacity >> 1) 为 0，经比较后第一个 if 判断成立，newCapacity = minCapacity（为 10 初始容量）第二个 if 判断不成立，即 newCapacity 不比 MAX_ARRAY_SIZE 大，则不会进入 hugeCapacity 方法。此时数组容量为 10，add 方法中 return true，size 增为 1。
• 当 add 第 11 个元素进入grow方法时，newCapacity为 15，比 minCapacity（为 11）大，第一、二个 if 判断都不成立，数组容量扩为 15，add 方法中 return true ，size 增为 11。

5. hugeCapacity() 方法

private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    //对minCapacity和MAX_ARRAY_SIZE进行比较
    //若minCapacity大，将Integer.MAX_VALUE作为新数组的大小
    //若MAX_ARRAY_SIZE大，将MAX_ARRAY_SIZE作为新数组的大小
    //MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE : MAX_ARRAY_SIZE;
}

System.arraycopy() 和 Arrays.copyOf() 方法

ArrayList 中大量调用了这两个方法，例：add() 中用到了 System.arraycopy，grow() 中用到了 Arrays.copyOf。

1. System.arraycopy() 方法

/**
 * src:源数组；
 * srcPos:源数组中的起始位置；
 * dest：目标数组；
 * destPos：目标数组中的起始位置；
 * length：要复制的数组元素的数量；
 */
public static native void arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
                                        int length);

对应的在 add() 方法中

/**
 * 在此列表中的指定位置插入指定的元素。
 */
public void add(int index, E element) {
    rangeCheckForAdd(index);

    ensureCapacityInternal(size + 1);  // Increments modCount!!
    //elementData：源数组；
    //index：源数组中的起始位置；
    //elementData：目标数组；
    //index + 1：目标数组中的起始位置；
    //size - index：要复制的数组元素的数量；
    System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
    elementData[index] = element;
    size++;
}

2. Arrays.copyOf()方法

public static byte[] copyOf(byte[] original, int newLength) {
    byte[] copy = new byte[newLength];
    System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
    return copy;
}

可以看到 Arrays.copyOf() 内还是调用的 System.arraycopy() 方法，但返回的数组长度重新定义了。

所以综合来看 System.arraycopy() 和 Arrays.copyOf() 两个方法，个人理解是：前者需要目标数组，将源数组拷贝到目标数组，而且可以选择拷贝的源数组起点和放入目标数组中的位置以及拷贝的长度；后者是系统自动在内部新建一个数组，主要是为了给原有数组扩容。

ensureCapacity() 方法

ArrayList 源码中有一个 ensureCapacity 方法，这个方法 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);
    }
}

根据源码可以初步判断，这是一个指定容量的方法。下面通过一个测试类，来测试一下该方法：

public static void main(String args[]){
	//调用ensureCapacity方法前
    ArrayList<Object> list = new ArrayList<Object>();
    final int N = 10000000;
    long startTime = System.currentTimeMillis();
    for (int i=0; i<N; i++){
        list.add(i);
    }
    long endTime = System.currentTimeMillis();
    System.out.println("使用ensureCapacity方法前："+(endTime - startTime));
    
	//调用ensureCapacity方法后
    list = new ArrayList<Object>();
    long startTime1 = System.currentTimeMillis();
    list.ensureCapacity(N);
    for (int i=0; i<N; i++){
        list.add(i);
    }
    long endTime1 = System.currentTimeMillis();
    System.out.println("使用ensureCapacity方法后："+(endTime1 - startTime1));
    }

输出结果：

通过运行结果，可以很明显的看出向 ArrayList 添加大量元素之前最好先使用ensureCapacity 方法，以减少增量从新分配的次数

add(int index, E element)

public void add(int index, E element) {
	//越界检查
	rangeCheckForAdd(index);
	//确认list容量，如果不够，容量加1
	ensureCapacityInternal(size + 1);  // Increments modCount!!
	//对数组进行复制处理，目的就是空出index的位置插入element，并将index后的元素位移一个位置
	System.arraycopy(elementData, index, elementData, index + 1,
					size - index);
	//将指定的index位置赋值为element
	elementData[index] = element;
	//实际容量+1
	size++;
}

越界检查：

//检查给出的索引index是否越界。
//若索引index大于数组容量size或为负数小于0，则抛出数组下标越界异常
private void rangeCheckForAdd(int index) {
    if (index > size || index < 0)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

get(int index)

public E get(int index) {
	//越界检查
   rangeCheck(index);
   //返回索引为index的元素
   return elementData(index);
}

这里的越界检查与上面 add(int index, E element) 方法中的不一样：这个方法并不检查index是否合法。比如是否为负数

//如果给出的索引index>=size，则抛出一个越界异常
private void rangeCheck(int index) {
    if (index >= size)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

remove(int index)

public E remove(int index) {
	//检查索引是否越界。如果参数指定索引index>=size，抛出一个越界异常
	rangeCheck(index);
	//结构性修改次数+1
	modCount++;
	//记录索引为index处的元素
	E oldValue = elementData(index);

	//删除指定元素后，需要左移的元素个数
	int numMoved = size - index - 1;
	//如果有需要左移的元素，就移动（移动后，该删除的元素就已经被覆盖了）
	if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,numMoved);
    //size减1，然后将索引为size-1处的元素置为null。为了让GC起作用，必须显式的为最后一个位置赋null值
    elementData[--size] = null; // clear to let GC do its work
	//返回被删除的元素
   return oldValue;
}

注意：这里移除一个元素后，将原数组最后一个位置的元素置为null是为了让GC起作用

set(int index, E element)

public E set(int index, E element) {
	//检查索引是否越界。如果参数指定索引index>=size，抛出一个越界异常
	rangeCheck(index);
	//记录被替换的元素
	E oldValue = elementData(index);
	//替换元素
	elementData[index] = element;
	//返回被替换的元素
	return oldValue;
}