ArrayList

基于 JDK 1.8。
ArrayList 类的继承关系：
这里写图片描述

实现的接口

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

这几个xxxAll()方法的含义基本也是可以顾名思义的，addAll添加，removeAll删除，containsAll检查是否包含了参数容器中的所有元素，只有全包含才返回true，retainAll**只保留参数容器中的元素**，其他元素会进行删除。

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

public boolean removeAll(Collection<?> c) {
    Objects.requireNonNull(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对其中一些方法进行了重写，以提供更为高效的实现。

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

RandomAccess

RandomAccess的定义为：

public interface RandomAccess {
}

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

该接口部分 javadoc：The primary purpose of this interface is to allow generic algorithms to alter their behavior to provide good performance when applied to either random or sequential access lists.

即实现了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);
}

Serializable

它也是一个标记接口。实现该接口的类是可序列化的。没有实现此接口的类将不能使它们的任意状态被序列化或逆序列化。

构造函数

ArrayList是一个泛型容器，新建ArrayList需要实例化泛型参数：

ArrayList<Integer> intList = new ArrayList<>(10);
ArrayList<Double> doubleList = new ArrayList<>();
ArrayList<String> strList = new ArrayList<>(new LinkedList<>());

源码：

//可以通过int来指定初始容量
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);
    }
}
//无参构造器
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
//以一个已有的Collection构建，数据会新拷贝一份
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。这是因为懒初始化，即在默认构造方法构造的集合类，占据尽可能少的内存空间（对于ArrayList来说，使用空数组来占据尽量少的空间，不使用 null 是为了避免 null 判断），在第一次进行包含有添加语义的操作时，才进行真正的初始化工作。

基本方法

添加元素

add 方法添加元素到末尾

ArrayList<Integer> intList = new ArrayList<>();
intList.add(123);
intList.add(456);
ArrayList<String> strList = new ArrayList<>();
strList.add("123");
strList.add("456");

长度方法

1.判断是否为空

public boolean isEmpty()

2.获取长度

public int size()

访问指定位置的元素

public E get(int index)

如：

ArrayList<String> list = new ArrayList<>();
list.add("123");
list.add("456");
for(int i=0,size = list.size(); i<size; i++){
    System.out.println(list.get(i));
}

查找元素

1.如果找到，返回索引位置，否则返回-1

public int indexOf(Object o)

2.从后往前找

public int lastIndexOf(Object o)

3.是否包含指定元素

public boolean contains(Object o)

相同的依据是equals方法返回true。如果传入的元素为null，则找null的元素。

删除元素

1.删除指定位置的元素

public E remove(int index)

返回值为被删对象。

2.删除指定对象

public boolean remove(Object o)

与indexOf一样，比较的依据的是equals方法，如果o为null，则删除值为null的元素。另外，remove只删除第一个相同的对象，也就是说，即使ArrayList中有多个与o相同的元素，也只会删除第一个。返回值为boolean类型，表示是否删除了元素。

3.删除所有元素

public void clear()

插入元素

在指定位置插入元素

public void add(int index, E element)

index为0表示插入最前面，index为ArrayList的长度表示插到最后面。

修改元素

修改指定位置的元素内容

public E set(int index, E element)

基本原理

组成

这是 ArrayList 的基本变量：

private static final int DEFAULT_CAPACITY = 10;

private static final Object[] EMPTY_ELEMENTDATA = {};

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

transient Object[] elementData; // non-private to simplify nested class access

private int size;

private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

可以看到 elementData 有一句注释：non-private to simplify nested class access，翻译即非private修饰来简化嵌套类访问；

数组的最大大小是 Integer.MAX_VALUE - 8，也就是 2147483639；

数组的默认大小为 10；

Add 方法

代码如下：

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

即调用了 ensureCapacityInternal() 方法，该方法是 private 修饰的方法，来确保数组容量是够的，代码如下：

private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

它先调用了 calculateCapacity() 方法，判断当前elementData是否为默认容量的空数组，若为空，则首次至少分配的大小为DEFAULT_CAPACITY，而 DEFAULT_CAPACITY 为10，代码如下：

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

接着调用 ensureExplicitCapacity() 方法，先 modCount++ ，然后再判断需要的长度是否大于当前数组的长度，如果大于，调用 grow() 方法，这段代码有一句 overflow-conscious code 注释，即代码考虑了溢出的情况，代码如下：

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

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

它用了 if (minCapacity - elementData.length > 0) 来考虑溢出，因为：

if (a>b)

if (a-b>0)

这两段代码是不同的，如果 a 为 Integer.MAX_VALUE + 1，而 b 为 Integer.MAX_VALUE - 1，此时因为 a 大于 int 所能表示的范围，所以 a 会溢出为负数，所以导致 a - b > 0 为 true，而 a > b 为 false。

int max = Integer.MAX_VALUE + 1;
int min = Integer.MAX_VALUE - 1;
//true
System.out.println(max - min > 0);
//false
System.out.println(max > min);

接下来继续 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倍。

Remove 方法

代码如下：

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，然后计算要移动的元素个数，从index往后的元素都往前移动一位，实际调用System.arraycopy() 方法移动元素。然后通过elementData[--size] = null将 size 减一，同时将最后一个位置设为null，设为null后就不再引用原来对象，如果原来对象也不再被其他对象引用，就可以被垃圾回收。

迭代

foreach用法

循环打印ArrayList中的每个元素，ArrayList支持foreach语法，比如：

ArrayList<Integer> intList = new ArrayList<>();
intList.add(1);
intList.add(2);
intList.add(3);
for (Integer integer : intList) {
    System.out.println(integer);
}

当然，这种循环也可以使用如下代码实现：

for(int i=0,size = intList.size(); i<size; i++){
    System.out.println(intList.get(i));
}

不过，foreach看上去更为简洁，而且，它适用于各种容器，更为通用。

foreach 语法，编译器会将它转换为类似如下代码：

Iterator var2 = intList.iterator();

while(var2.hasNext()) {
    Integer integer = (Integer)var2.next();
    System.out.println(integer);
}

Collection 接口继承了 Iterable 接口，Iterable 接口定义为：

public interface Iterable<T> {

    Iterator<T> iterator();

    default void forEach(Consumer<? super T> action) {
        Objects.requireNonNull(action);
        for (T t : this) {
            action.accept(t);
        }
    }

    default Spliterator<T> spliterator() {
        return Spliterators.spliteratorUnknownSize(iterator(), 0);
    }
}

在 jdk1.8 之前没有两个 default 方法，这是为了实现 java 函数式编程而加入的方法。Iterator<T> iterator()即需要实现类实现 iterator() 方法，返回一个实现了 Iterator 接口的对象。

Iterator 接口定义为：

public interface Iterator<E> {

    boolean hasNext();

    E next();

    default void remove() {
        throw new UnsupportedOperationException("remove");
    }

    default void forEachRemaining(Consumer<? super E> action) {
        Objects.requireNonNull(action);
        while (hasNext())
            action.accept(next());
    }
}

最后一个也是为了实现 java 函数式编程而加入的方法。

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

总结：

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

ListIterator

除了iterator()，ArrayList 还提供了两个返回 Iterator 接口的方法：

public ListIterator listIterator()
public ListIterator listIterator(int index)

ListIterator 扩展了 Iterator 接口，增加了一些方法，向前遍历、添加元素、修改元素、返回索引位置等，添加的方法有：

public interface ListIterator extends Iterator {
boolean hasPrevious();
E previous();
int nextIndex();
int previousIndex();
void set(E e);
void add(E e);
}

listIterator() 方法返回的迭代器从0开始，而 listIterator(int index) 方法返回的迭代器从指定位置 index 开始，比如，从末尾往前遍历，代码为：

public void reverseTraverse(List<Integer> list){
    ListIterator<Integer> it = list.listIterator(list.size());
    while(it.hasPrevious()){
        System.out.println(it.previous());
    }
}

迭代的陷阱

关于迭代器，如果在迭代的中间调用容器的删除方法，会抛出 java.util.ConcurrentModificationException 错误，代码如下：

ArrayList<Integer> intList = new ArrayList<>();
intList.add(1);
intList.add(2);
intList.add(3);
for (Integer integer : intList) {
    intList.remove(integer);
}

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

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

ArrayList<Integer> intList = new ArrayList<>();
intList.add(1);
intList.add(2);
intList.add(3);
Iterator<Integer> iterator = intList.iterator();
while (iterator.hasNext()){
iterator.next();
iterator.remove();
}
//0
System.out.println(intList.size());

iterator 实现原理

ArrayList 中 iterator 方法的实现：

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

Itr是一个成员内部类，实现了Iterator接口，代码如下：

private class Itr implements Iterator {
int cursor; // index of next element to return
int lastRet = -1; // index of last element returned; -1 if no such
int expectedModCount = modCount;

//…

}

它有三个成员变量，其中 cursor 代表下一个要返回的元素位置，lastRet 表示上一个元素返回的位置，expectedModCount 表示期望的修改次数，初始化为外部类当前的修改次数 modCount。

每次发生结构性变化的时候 modCount 都会增加，而每次迭代器操作的时候都会检查 expectedModCount 是否与 modCount 相同，这样就能检测出结构性变化。这便是 modCount++ 的缘故。

它的 hasNext()，直接将 cursor 和 size 比较，代码如下：

public boolean hasNext() {
    return 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();
}

直接检查是否发生了结构性变化，如果没有，就更新 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() 方法，通过迭代器删除所有元素：

Iterator<Integer> iterator = intList.iterator();
while (iterator.hasNext()){
   iterator.remove();
}

但会抛出 java.lang.IllegalStateException 异常，正确应该：

Iterator<Integer> iterator = intList.iterator();
while (iterator.hasNext()){
   iterator.next();
   iterator.remove();
}

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

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

迭代器的好处

直接通过 size() 和 get(int index) 方法，也可以迭代访问所有元素，不过，foreach语法更为简洁一些，更重要的是，迭代器语法更为通用，它适用于各种容器类。

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

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

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

特点分析

ArrayList，其内部采用动态数组实现，所以：

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

ArrayList 剖析