ArrayList原理解析

来源：
Java编程的逻辑
JDK源码

1 基本原理

1.1 内部组成

内部有一个数组elementData，一般会有一些预留的空间，有一个整数size记录实际的元素个数，如下所示：

private transient Object[] elementData;
private int size;

各种public方法内部操作的基本都是这个数组和这个整数；
elementData会随着实际元素个数的增多而重新分配，而size则始终记录实际的元素个数。

1.2 Add

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

它首先调用ensureCapacityInternal确保数组容量是够的；
ensureCapacityInternal的代码如下：

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

    ensureExplicitCapacity(minCapacity);
}

它先判断数组是不是空的，如果是空的，则首次至少要分配的大小为DEFAULT_CAPACITY，DEFAULT_CAPACITY的值为10，接下来调用ensureExplicitCapacity，代码为：

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

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

modCount表示内部的修改次数，modCount++是增加修改次数，其作用为todo

如果需要的长度大于当前数组的长度，则调用grow方法。

这段代码前面有个注释：overflow-conscious code，即代码考虑了溢出这种情况；
溢出：假设a,b都是int，下面两行代码是不一样的：

1 if(a>b)
2 if(a-b>0)

为什么呢？考虑a=Integer.MAX_VALUE, b=Integer.MIN_VALUE：

a>b为true

但由于溢出，a-b的结果为-1

反之，再考虑a=Integer.MIN_VALUE, b=Integer.MAX_VALUE:

a>b为false

但由于溢出，a-b的结果为1。

不过，在a, b都为正数且数值没有那么大的情况下，一般也没有溢出问题，为便于理解，在后续的分析中，我们将忽略溢出问题。

接下来，看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);
}

排除边缘情况，长度增长的主要代码为：

int newCapacity = oldCapacity + (oldCapacity >> 1);

右移一位相当于除2，所以，newCapacity相当于oldCapacity的1.5倍。

指定位置的插入：

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++;
}

1.3 Remove

增加了modCount；
计算要移动的元素个数，从index往后的元素都往前移动一位，实际调用System.arraycopy方法移动元素；
elementData[–size] = null;这行代码将size减一，同时将最后一个位置设为null，设为null后就不再引用原来对象，如果原来对象也不再被其他对象引用，就可以被垃圾回收。

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;
}

2 迭代

2.1 foreach的基本原理

例子：

ArrayList<Integer> intList = new ArrayList<Integer>();
intList.add(123);
intList.add(456);
intList.add(789);
for(Integer a : intList){
    System.out.println(a);
}

转换为类似如下代码：使用迭代器，用来顺序访问集合元素

Iterator<Integer> it = intList.iterator();
while(it.hasNext()){
    System.out.println(it.next());
}

2.2 迭代器接口

ArrayList实现了Iterable接口，Iterable表示可迭代，它的定义为：

public interface Iterable<T> {
    Iterator<T> iterator();
}

定义很简单，就是要求实现iterator方法。iterator方法的声明为：

public Iterator<E> iterator()

它返回一个实现了Iterator接口的对象，Iterator接口的定义为：

public interface Iterator<E> {
    boolean hasNext();
    E next();
    void remove();
}

hasNext()判断是否还有元素未访问；
next()返回下一个元素；
remove()删除最后返回的元素；

只读访问的基本模式就类似于：

Iterator<Integer> it = intList.iterator();
while(it.hasNext()){
    System.out.println(it.next());
}

只要对象实现了Iterable接口，就可以使用foreach语法，编译器会转换为调用Iterable和Iterator接口的方法。

Iterable和Iterator区别：

• Iterable表示对象可以被迭代，它有一个方法iterator()，返回Iterator对象，实际通过Iterator接口的方法进行遍历。
• 如果对象实现了Iterable，就可以使用foreach语法。
• 类可以不实现Iterable，也可以创建Iterator对象。

2.3 迭代的陷阱

关于迭代器，有一种常见的误用，就是在迭代的中间调用容器的删除方法，比如要删除一个整数ArrayList中所有小于100的数，直觉上，代码可以这么写：

public void remove(ArrayList<Integer> list){
    for(Integer a : list){
        if(a <= 100){
            list.remove(a);
        }
    }
}

但，运行时会抛出异常：

java.util.ConcurrentModificationException

发生了并发修改异常，为什么呢？迭代器内部会维护一些索引位置相关的数据，要求在迭代过程中，容器不能发生结构性变化，否则这些索引位置就失效了。所谓结构性变化就是添加、插入和删除元素，只是修改元素内容不算结构性变化。

如何避免异常呢？可以使用迭代器的remove方法，如下所示：

public static void remove(ArrayList<Integer> list){
    Iterator<Integer> it = list.iterator();
    while(it.hasNext()){
        if(it.next() <= 100){
            it.remove();
        }
    }
}

2.4 迭代器实现的原理

ArrayList中iterator方法的实现，代码为：

public Iterator<E> iterator() {
    return new Itr();
}

新建了一个Itr对象，Itr是一个成员内部类，实现了Iterator接口，声明为：

private class Itr implements Iterator<E>

Itr有三个实例成员变量，为：

int cursor;       // 下一个要返回的元素位置
int lastRet = -1; // 最后一个返回的索引位置
int expectedModCount = modCount;//期望的修改次数，初始化为外部类当前的修改次数modCount（成员内部类可以直接访问外部类的实例变量。）

迭代器如何知道发生了结构性变化，并抛出异常：每次发生结构性变化的时候modCount都会增加，而每次迭代器操作的时候都会检查expectedModCount是否与modCount相同，这样就能检测出结构性变化。

我们来具体看下，它是如何实现Iterator接口中的每个方法的：

先看hasNext()，代码为：

public boolean hasNext() {
    return cursor != size;
}

cursor与size比较，比较直接

看next()方法：

public E next() {
    checkForComodification();
    int i = cursor;
    if (i >= size)
        throw new NoSuchElementException();
    Object[] elementData = ArrayList.this.elementData;
    if (i >= elementData.length)
        throw new ConcurrentModificationException();
    cursor = i + 1;
    return (E) elementData[lastRet = i];
}

首先调用了checkForComodification，它的代码为：

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

总结：next()前面部分主要就是在检查是否发生了结构性变化，如果没有变化，就更新cursor和lastRet的值，以保持其语义，然后返回对应的元素。

remove的代码为：

public void remove() {
    if (lastRet < 0)
        throw new IllegalStateException();
    checkForComodification();

    try {
        ArrayList.this.remove(lastRet);
        cursor = lastRet;
        lastRet = -1;
        expectedModCount = modCount;
    } catch (IndexOutOfBoundsException ex) {
        throw new ConcurrentModificationException();
    }
}

它调用了ArrayList的remove方法，但同时更新了cursor, lastRet和expectedModCount的值，所以它可以正确删除。

不过，需要注意的是，调用remove方法前必须先调用next，比如，通过迭代器删除所有元素，直觉上，可以这么写：

public static void removeAll(ArrayList<Integer> list){
    Iterator<Integer> it = list.iterator();
    while(it.hasNext()){
        it.remove();    
    }
}

实际运行，会抛出异常：

java.lang.IllegalStateException

正确写法是：

public static void removeAll(ArrayList<Integer> list){
    Iterator<Integer> it = list.iterator();
    while(it.hasNext()){
        it.next();
        it.remove();
    }
}

当然，如果只是要删除所有元素，ArrayList有现成的方法clear()。

listIterator()的实现使用了另一个内部类ListItr，它继承自Itr，基本思路类似

2.5 迭代器的好处

foreach语法更为简洁一些，更重要的是，迭代器语法更为通用，它适用于各种容器类。

此外，迭代器表示的是一种关注点分离的思想，将数据的实际组织方式与数据的迭代遍历相分离，是一种常见的设计模式。
需要访问容器元素的代码只需要一个Iterator接口的引用，不需要关注数据的实际组织方式，可以使用一致和统一的方式进行访问。

而提供Iterator接口的代码了解数据的组织方式，可以提供高效的实现。在ArrayList中, size/get(index)语法与迭代器性能是差不多的，但在其他容器中，则不一定，比如LinkedList，迭代器性能就要高很多。

从封装的思路上讲，迭代器封装了各种数据组织方式的迭代操作，提供了简单和一致的接口。

3 ArrayList实现的接口

3.1 Collection

Collection表示一个数据集合，数据间没有位置或顺序的概念，接口定义为：

public interface Collection<E> extends Iterable<E> {
    int size();
    boolean isEmpty();
    boolean contains(Object o);
    Iterator<E> iterator();
    Object[] toArray();
    <T> T[] toArray(T[] a);
    boolean add(E e);
    boolean remove(Object o);
    boolean containsAll(Collection<?> c);
    boolean addAll(Collection<? extends E> c);
    boolean removeAll(Collection<?> c);
    boolean retainAll(Collection<?> c);
    void clear();
    boolean equals(Object o);
    int hashCode();
}

抽象类AbstractCollection对这几个方法都提供了默认实现；
实现的方式就是利用迭代器方法逐个操作；
比如说removeAll方法代码为：

public boolean removeAll(Collection<?> c) {
    boolean modified = false;
    Iterator<?> it = iterator();
    while (it.hasNext()) {
        if (c.contains(it.next())) {
            it.remove();
            modified = true;
        }
    }
    return modified;
}

ArrayList继承了AbstractList，而AbstractList又继承了AbstractCollection，ArrayList对其中一些方法进行了重写，以提供更为高效的实现

3.2 List

List表示有顺序或位置的数据集合，它扩展了Collection，增加的主要方法有：

boolean addAll(int index, Collection<? extends E> c);
E get(int index);
E set(int index, E element);
void add(int index, E element);
E remove(int index);
int indexOf(Object o);
int lastIndexOf(Object o);
ListIterator<E> listIterator();
ListIterator<E> listIterator(int index);
List<E> subList(int fromIndex, int toIndex);

3.3 RandomAccess

RandomAccess的定义为：

public interface RandomAccess {
}

没有任何代码的接口在Java中被称之为标记接口，用于声明类的一种属性。

这里，实现了RandomAccess接口的类表示可以随机访问；
可随机访问就是具备类似数组那样的特性，数据在内存是连续存放的，根据索引值就可以直接定位到具体的元素，访问效率很高。
如LinkedList就不能随机访问。

声明RandomAccess的作用：
主要用于一些通用的算法代码中，它可以根据这个声明而选择效率更高的实现；
比如说，Collections类中有一个方法binarySearch，在List中进行二分查找，它的实现代码就根据list是否实现了RandomAccess而采用不同的实现机制，如下所示：

public static <T>
int binarySearch(List<? extends Comparable<? super T>> list, T key) {
    if (list instanceof RandomAccess || list.size()<BINARYSEARCH_THRESHOLD)
        return Collections.indexedBinarySearch(list, key);
    else
        return Collections.iteratorBinarySearch(list, key);
}

4 ArrayList的其他方法

构造方法

ArrayList还有两个构造方法

public ArrayList(int initialCapacity)
public ArrayList(Collection<? extends E> c)

第一个方法以指定的大小initialCapacity初始化内部的数组大小，代码为：

this.elementData = new Object[initialCapacity];

在事先知道元素长度的情况下，或者，预先知道长度上限的情况下，使用这个构造方法可以避免重新分配和拷贝数组。

第二个构造方法以一个已有的Collection构建，数据会新拷贝一份。

与数组的相互转换

ArrayList中有两个方法可以返回数组

public Object[] toArray()
public <T> T[] toArray(T[] a) 

第一个方法返回是Object数组，代码为：

public Object[] toArray() {
    return Arrays.copyOf(elementData, size);
}

第二个方法返回对应类型的数组，如果参数数组长度足以容纳所有元素，就使用该数组，否则就新建一个数组，比如：

ArrayList<Integer> intList = new ArrayList<Integer>();
intList.add(123);
intList.add(456);
intList.add(789);

Integer[] arrA = new Integer[3];
intList.toArray(arrA);
Integer[] arrB = intList.toArray(new Integer[0]);

System.out.println(Arrays.equals(arrA, arrB));

输出为true，表示两种方式都是可以的。

Arrays中有一个静态方法asList可以返回对应的List，如下所示：

Integer[] a = {1,2,3};
List<Integer> list = Arrays.asList(a);

需要注意的是，这个方法返回的List，它的实现类是Arrays类的一个内部类，在这个内部类的实现中，内部用的的数组就是传入的数组，没有拷贝，也不会动态改变大小，所以对数组的修改也会反映到List中，对List调用add/remove方法会抛出异常。

要使用ArrayList完整的方法，应该新建一个ArrayList，如下所示：

List<Integer> list = new ArrayList<Integer>(Arrays.asList(a));

容量大小控制

ArrayList还提供了两个public方法，可以控制内部使用的数组大小，一个是：

public void ensureCapacity(int minCapacity)

它可以确保数组的大小至少为minCapacity，如果不够，会进行扩展。如果已经预知ArrayList需要比较大的容量，调用这个方法可以减少ArrayList内部分配和扩展的次数。

另一个方法是：

public void trimToSize()

它会重新分配一个数组，大小刚好为实际内容的长度。调用这个方法可以节省数组占用的空间。

5 特点分析

内部采用动态数组实现：

• 可以随机访问，按照索引位置进行访问效率很高，效率是O(1)
• 除非数组已排序，否则按照内容查找元素效率比较低，具体是O(N)
• 添加元素的效率比较低：重新分配和拷贝数组的开销被平摊了，具体来说，添加N个元素的效率为O(N)。
• 插入和删除元素的效率比较低，因为需要移动元素，具体为O(N)