ArrayList源码学习（一）

ArrayList 是 List 接口基于数组并且可调整大小的实现类，它实现了列表规范的所有可选操作，该类允许存储所有类型元素包括null。size 、 isEmpty 、 get 、 set 、 iterator 和 listIterator 操作在恒定时间内运行。 add操作在分摊常数 time 内运行，即添加 n 个元素需要 O(n) 时间。此类的iterator和listIterator方法返回的iterator是快速失败的：如果在创建迭代器后的任何时间以任何方式修改列表结构，除了通过迭代器自己的remove或add方法，迭代器将抛出异常。

概述

下图展示了 ArrayList 的继承关系：

重要继承关系

• java.util.List实现List的方法，遵从列表的规范
• java.lang.Cloneable标记该类的实例允许克隆
• java.util.RandomAccess标记接口来指示类支持快速（通常是恒定时间）随机访问

成员变量

类中有一些成员变量和常量：

// 定义了默认的初始化容量
private static final int DEFAULT_CAPACITY = 10;
// 记录ArrayList包含元素的个数
private int size;
// 存储元素的数组，上面的 size 即为该数组的长度
transient Object[] elementData;
// 定义了上面数组可定义的最大容量，但是还受VM的限制，该值仅供参考
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
// 构造容量为0的列表使用的共享数组
private static final Object[] EMPTY_ELEMENTDATA = {};
// 列表默认初始化时使用的共享数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

另外还有一个从AbstractList中继承来的属性modCount，记录了列表在结构上被修改的次数，指那些改变列表大小的修改或者其他方式扰乱列表，这样正在进行迭代的列表可能会产生不正确的结果。这个字段将在列表添加删除元素时被修改，而在iterator中被使用，提供了迭代器快速失败的行为。

构造函数

ArrayList 提供了三种构造函数，无参构造和带集合类型参数的构造遵循了 Collection 接口的规范，另外一个比较重要的构造函数是创建一个指定初始容量的空列表。

// 构造一个初始容量为 10 的空列表
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

无参构造函数只是将内部数组初始化指向一个空数组常量，当在第一次给列表添加元素的时候，会判断是否是该空数组对象，将给该列表初始容量为默认值10，详细会在下文[添加元素 & 扩容机制](#添加元素 & 扩容机制)中介绍。

// 按照集合的迭代器返回的顺序构造一个包含指定集合元素的列表
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;
    }
}

首先将指定集合的元素转换成一个新的数组赋值给 elementData 。然后根据数组长度进行判断：长度为0则直接将数组指向共享的空数组对象；如果长度不为0，并且数组类型不是Object[]（根据文档，Collection.toArray()可能会错误的返回非Object[]类型的结果），则将数组元素拷贝到正确类型的数组中。

// 构造一个具有指定初始容量的空列表
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);
    }
}

该构造函数接收initialCapacity初始化列表容量：

1. 参数大于0，就以此容量初始化元素数组；
2. 参数等于0， 以共享的空数组对象初始化元素数组；
3. 参数小于0，为无效参数，抛出异常。

添加元素 & 扩容机制

ArrayList 中有四种方法添加元素，在列表末尾插入元素、在指定位置插入元素和在列表尾部插入集合、在指定位置插入集合。

boolean add(E e)

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

此方法从List、Collection接口实现而来，遵循了它们的规范，如果列表拒绝添加此元素，需要抛出异常，否则将在调用成功后返回true，这确保了调用返回后列表始终包含此元素的不变性。

第三行是插入元素前确保列表容量可用，包含了ArrayList的扩容机制和对modCount的修改；接着就将元素直接存入到elementData数组中，size增加一；最后直接返回true，调用成功。这个方法的逻辑比较简单，重点在于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;
}

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;
    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

调用此方法的参数是添加新元素所需的最小容量，接着又使用这个最小容量计算出实际需要的容量，这里是兼容了使用默认构造器创建的ArrayList。如果是无参构造的空数组，则在默认容量10和最小容量之间选取最大值作为最终容量，如果不是就直接用所需最小容量minCapacity。

明确了所需容量后，就将进行扩容操作了，首先递增了成员变量modCount记录修改次数，表示列表大小被修改。然后判断了当所需容量比当前elementData的长度大才调用实际扩容方法，源码注释说明目的是为了防溢出，这个意图还得再进到下面的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);
}

private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
    MAX_ARRAY_SIZE;
}

扩容逻辑中，取得当前数组的长度，并扩大到了之前的1.5倍用以新的列表容量，然后对一些特殊情况进行判断：

1. 如果扩大后的新容量比所需最小容量还小，就直接使用这个最小容量；
2. 如果扩大后的新容量比规定的最大容量还大，就直接使用最大容量hugeCapacity(minCapacity)；

hugeCapacity(minCapacity)方法中如果容量大于规定的值，就直接使用Integer.MAX_VALUE作为容量返回，但这在运行期间还会受到VM规定的大小限制，因此这个值是不准确的。确定完容量后，就直接将元素拷贝到新的数组中，至此扩容结束。

其他三个添加元素的方法都调用了ensureCapacityInternal()确保列表容量可用，所以着重介绍其他的代码逻辑。

void add(int index, E element)

// 在此列表中的指定位置插入指定元素。 将当前在该位置的元素（如果有）和任何后续元素向右移动
public void add(int index, E element) {
    rangeCheckForAdd(index);
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
    elementData[index] = element;
    size++;
}
// 专为add和addAll使用的范围检查方法
private void rangeCheckForAdd(int index) {
    if (index > size || index < 0)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

private String outOfBoundsMsg(int index) {
    return "Index: "+index+", Size: "+size;
}

指定位置插入的第一步就是要校验位置（数组索引）的有效性，当索引小于0或者大于当前元素的个数的时候便认为无效，会抛出数组越界异常。下一步就是确认容量可用。

重要的逻辑是将要插入位置及以后的元素向后移，腾出空闲位置放置要添加的元素，这里用了System.arraycopy()插入位置及以后的元素向后拷贝了一次。再将元素放入到index处，使size加一。

boolean addAll(Collection<? extends E> c)

// 按照指定集合的迭代器返回的顺序，将指定集合中的所有元素追加到此列表的末尾
public boolean addAll(Collection<? extends E> c) {
    Object[] a = c.toArray();
    int numNew = a.length;
    ensureCapacityInternal(size + numNew);  // Increments modCount
    System.arraycopy(a, 0, elementData, size, numNew);
    size += numNew;
    return numNew != 0;
}

该方法中的逻辑比较简单，就是将指定的集合转换为数组并且拷贝到原数组中。

boolean addAll(int index, Collection<? extends E> c)

// 从指定位置开始，将指定集合中的所有元素插入此列表。 将当前在该位置的元素（如果有）和任何后续元素向右移动（增加它们的索引）。 新元素将按照指定集合
// 的迭代器返回的顺序出现在列表中
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;
}

该方法的逻辑可以看成是add(int index, E element)和addAll(Collection<? extends E> c)的组合体，当插入元素的位置不同时，操作列表数组的逻辑有差别。

1. 当插入位置在列表中间时，需要先将index及以后的元素后移，然后再将新集合数组拷贝进去，共执行两次数组拷贝。
2. 当插入位置在列表末尾时，不需要移动元素，只将新集合数组拷贝到列表数组结尾。

列表访问操作

E get(int index)

// 返回此列表中指定位置的元素
public E get(int index) {
    rangeCheck(index);
    return elementData(index);
}
// 检查索引是否在有效范围内，只在列表访问操作前调用
private void rangeCheck(int index) {
    if (index >= size)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

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

通过索引访问的方法比较简单，只需检查确认索引有效后就能直接访问列表数组即可。

E set(int index, E element)

// 用指定的元素替换此列表中指定位置的元素，并返回旧元素
public E set(int index, E element) {
    rangeCheck(index);
    E oldValue = elementData(index);
    elementData[index] = element;
    return oldValue;
}

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);
    elementData[--size] = null; // clear to let GC do its work
    return oldValue;
}

删除元素操作将减小列表的容量，修改了列表结构，因此需要将modCount增加。numMoved是计算出需要移动元素的个数，仍旧通过拷贝的方法移动index后面的元素。最后将列表数组最后的位置引用null，这样使垃圾回收时能把没有引用的对象清理掉。

boolean remove(Object o)

// 从此列表中删除第一次出现的指定元素（如果存在）。 如果列表不包含该元素，则它保持不变
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;
}
// 跳过索引检查且没有返回值的私有删除方法，只供上面调用
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
}

通过指定元素删除就需要确定元素是否存在于列表内，文档规范是用o==null ? get(i)==null : o.equals(get(i))来确认元素相同，因此分为null和非null两类元素循环比对，列表中是否存在相同元素，如果存在则执行fastRemove方法删除。

其他操作

// 返回此列表中指定元素第一次出现的索引，如果此列表不包含该元素，则返回 -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;
}
// 返回此列表中指定元素最后一次出现的索引，如果此列表不包含该元素，则返回 -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;
}
// 如果此列表包含指定的元素，则返回true。 具体来说，当且仅当此列表包含至少一个元素e使得
// (o==null ? e==null : o.equals(e))时才返回true
public boolean contains(Object o) {
    return indexOf(o) >= 0;
}

上述代码前两个方法是通过元素找索引，比对元素仍然是按照文档规范的o==null ? get(i)==null : o.equals(get(i))进行操作，遍历列表数组依次对比，只是方法一找第一次出现是正向遍历，方法二找最后一次出现反向遍历。

contains方法则巧妙的使用了indexOf进行实现，如果元素第一次出现的索引大于0，就说明在列表中存在。

// 从此列表中删除包含在指定集合中的所有元素
public boolean removeAll(Collection<?> c) {
    Objects.requireNonNull(c);
    return batchRemove(c, false);
}
// 从该列表中删除所有未包含在指定集合中的元素
public boolean retainAll(Collection<?> c) {
    Objects.requireNonNull(c);
    return batchRemove(c, true);
}

private boolean batchRemove(Collection<?> c, boolean complement) {
    final Object[] elementData = this.elementData;
    int r = 0, w = 0;
    boolean modified = false;
    try {
        for (; r < size; r++)
            if (c.contains(elementData[r]) == complement)
                elementData[w++] = elementData[r];
    } finally {
        // Preserve behavioral compatibility with AbstractCollection,
        // even if c.contains() throws.
        if (r != size) {
            System.arraycopy(elementData, r, elementData, w, size - r);
            w += size - r;
        }
        if (w != size) {
            // clear to let GC do its work
            for (int i = w; i < size; i++)
                elementData[i] = null;
            modCount += size - w;
            size = w;
            modified = true;
        }
    }
    return modified;
}

上面两个方法包含相同的批量删除元素的逻辑，只是目标元素不同，因此只通过complement标识区分调用batchRemove执行删除逻辑：

1. 声明r、w存储当前列表数组读和写的下标，然后在try代码块中遍历列表，将需要留下的元素移到最前面，通过contains()判断是否需要留下。
2. 到finally代码块中，当r != size时（即上面遍历没有到正常结束，可能出错），将剩余为遍历到的元素也向前拷贝到已保留元素的末尾，都视为要保留的元素，此时将w后移到保留元素末尾。
3. 确认完所有要保留的元素后，剩下就是删除不需要保留的元素了，也就是从w到列表末尾的所有元素。所以这里遍历了剩余索引赋为null，并修改modCount和size的值。

列表转换为数组

// 以适当的顺序（从第一个元素到最后一个元素）返回一个包含此列表中所有元素的数组。
public Object[] toArray() {
    return Arrays.copyOf(elementData, size);
}
// 以适当的顺序（从第一个元素到最后一个元素）返回一个包含此列表中所有元素的数组，允许指定数组接收。
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;
}

方法一将列表元素返回成一个数组，这个数组是“安全的”新数组，列表本身对其没有任何引用，因此可以自由的修改该数组。方法里Arrays.copyOf()源码也是使用ArrayList源码中多次出现的System.arraycopy()方法，这里不再解析其源码。

方法二与方法一的区别就是允许使用现有的数组对象接收列表元素。通过查看源码，可以看出其中的实现逻辑：

1. 首先，当指定的数组容量比列表长度小，也就容纳不了列表所有元素，这时将使用指定数组的运行时类型和此列表的大小分配一个新数组，拷贝元素返回。
2. 当数组能容纳列表所有元素时，就直接将列表内元素全部拷贝到指定数组中。
3. 最后一步，判断如果数组容量比列表元素数量大，即数组仍有剩余空间时，将数组中列表元素末尾之后的位置赋为null（仅当明确列表不包含任何空元素时，有助于确定列表的长度）。

本文主要介绍了ArrayList类的构造逻辑和主要的方法源码，仅以个人学习理解的角度对该类做了浅析。由于篇幅有限，剩余包括迭代器等的其他内容将会另起一篇，敬请关注。

原文地址 --- Java容器源码学习分析专题——ArrayList源码学习（一）