ArrayList 和 LinkedList 源码分析

List 表示的就是线性表，是具有相同特性的数据元素的有限序列。它主要有两种存储结构，顺序存储和链式存储，分别对应着 ArrayList 和 LinkedList 的实现，接下来以 jdk7 代码为例，对这两种实现的核心源码进行分析。

1. ArrayList 源码分析

ArrayList 是基于数组实现的可变大小的集合，底层是一个 Object[] 数组，可存储包括 null 在内的所有元素，默认容量为 10。元素的新增和删除，本质就是数组元素的移动。

1.1 add 操作

ArrayList 内部有一个 size 成员变量，记录集合内元素总数，add 操作的本质就是 elementData[size++] = e，为了保证插入成功，会按需对数组进行扩容，扩容代码如下：

private void grow(int minCapacity) {
 // 有可能会溢出
 int oldCapacity = elementData.length;
 // 相当于 oldCapacity+(oldCapacity/2)，扩大 1.5 倍
 int newCapacity = oldCapacity + (oldCapacity >> 1);
 // 确保新容量不小于 minCapacity
 if (newCapacity - minCapacity < 0)
 newCapacity = minCapacity;
 if (newCapacity - MAX_ARRAY_SIZE > 0)
 // 检查扩充的最小容量是否溢出，如果溢出值会小于 0
 newCapacity = hugeCapacity(minCapacity);
 // 生成一个新数组，旧数组没有被引用会被垃圾回收
 elementData = Arrays.copyOf(elementData, newCapacity);
}

add 操作还有一个指定位置的插入，来看具体实现（本文首发于微信公众号：顿悟源码，qq交流群：673986158）：

public void add(int index, E element) {
 // 检查下标是否有效
 // 可能会抛出 IndexOutOfBoundsException 异常
 rangeCheckForAdd(index);
 // 确保足够的容量插入成功
 ensureCapacityInternal(size + 1); // Increments modCount!!
 // 把从 index 位置开始的所有元素后移一位
 System.arraycopy(elementData, index, elementData, index + 1,
 size - index);
 // 插入新元素 
 elementData[index] = element;
 size++; // 总数加 1
}

1.2 remove 操作

remove 分为两种，按下标删除和按元素删除。按元素首先会遍历找到匹配元素的位置下标，然后按下标进行删除：

public E remove(int index) {
 // 检查下标位置是否有效
 rangeCheck(index);
 // 更新列表结构的修改次数
 modCount++;
 E oldValue = elementData(index);
 int numMoved = size - index - 1;
 if (numMoved > 0)
 // 将 index 后的所有元素前移一位
 System.arraycopy(elementData, index+1, elementData, index,
 numMoved);
 // 释放引用 
 elementData[--size] = null; // clear to let GC do its work
 return oldValue;
}

1.3 遍历

常见的遍历代码如下：

for (int i=0; i<list.size(); i++) {
 list.get(i); // do something
}

这种遍历方式的缺点是，在遍历过程中如果修改集合结构（比如调用 remove 或 add），没有任何异常，可能会导致意想不到的输出，另外一种遍历方式，比如：

for (T obj:list) {
 // do something
}

遍历的过程中，如果使用不正当的删除操作（比如list.remove）就会抛出 ConcurrentModificationException，因为它默认使用的 Iterator 遍历方式。

Iterator 是 jdk 为所有集合遍历而设计，并且是 fail-fast 快速失败的。在 iterator 遍历过程中，如果 List 结构不是通过迭代器本身的 add/remove 方法而改变，那么就会抛出 ConcurrentModificationException。注意，在不同步修改的情况下，它不能保证会发生，它只是尽力检测并发修改的错误。

fail-fast 是通过一个 modCount 字段来实现的，这个字段记录了列表结构的修改次数，当调用 iterator() 返回迭代器时，会缓存 modCount 当前的值，如果这个值发生了不期望的变化，那么就会在 next, remove 操作中抛出异常，核心代码如下：

private class Itr implements Iterator<E> {
 int cursor; // 下一个要返回的元素下标，初始为 0
 // 最后一个返回的元素下标，-1 表示没有元素
 int lastRet = -1;
 // 缓存 modCount 的值
 int expectedModCount = modCount;
 // 是否还有元素可读
 public boolean hasNext() {
 return cursor != size;
 }
 public E next() {
 // 检查 modCount 值是否变化
 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];
 }
 // 调用 iterator 自身的 remove 
 public void remove() {
 if (lastRet < 0)
 throw new IllegalStateException();
 checkForComodification();
 try {
 // 删除元素，此时 modCount 值改变
 ArrayList.this.remove(lastRet);
 // 移除会把lastRet后面的元素前移一位
 cursor = lastRet; // 所以还是从 lastRet 开始读
 lastRet = -1;
 // 重置 modCount 期望值
 expectedModCount = modCount;
 } catch (IndexOutOfBoundsException ex) {
 throw new ConcurrentModificationException();
 }
 }
 final void checkForComodification() {
 // 如果变化，检测到并发修改，抛出异常
 if (modCount != expectedModCount)
 throw new ConcurrentModificationException();
 }
}

2. LinkedList 源码分析

LinkedList 底层是一个双向链表，它不仅实现了 List 接口，还实现了 Deque 接口，所以既可以把它当作一般线性表，也可当作受限线性表主要是栈和队列。

双向链表的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点，LinkedList 中的节点定义如下：

private static class Node<E> {
 E item;// 数据
 Node<E> next; // 后继节点
 Node<E> prev; // 前驱节点
 Node(Node<E> prev, E element, Node<E> next) {
 this.item = element;
 this.next = next;
 this.prev = prev;
 }
}

它包含三个成员变量：

• int size = 0: 结点总数
• Node first: 头结点
• Node last: 尾结点

2.1 头插法和尾插法

链表插入时有两种插入方法，头插法和尾插法，关键操作就是正确的断链和续链。头插法的代码如下：

private void linkFirst(E e) {
 // 使用临时变量指向头节点
 final Node<E> f = first;
 // 新节点前驱为 null，后继为 first
 final Node<E> newNode = new Node<>(null, e, f);
 first = newNode;
 if (f == null) // 链表为空，同时为最后一个节点
 last = newNode;
 else // 否则作为前驱节点
 f.prev = newNode;
 size++;
 modCount++;
}

头插法的结果是逆序的，尾插法的结果是顺序的。尾插法的操作也比较简单，直接修改 last 引用即可：

void linkLast(E e) {
 // 使用临时变量指向尾节点
 final Node<E> l = last;
 // 新节点前驱为 last，后继为 null
 final Node<E> newNode = new Node<>(l, e, null);
 // 重置 last 指向节点
 last = newNode;
 if (l == null)// 链表为空
 first = newNode; // 第一个节点
 else // 否则作为前一个的后继
 l.next = newNode;
 size++; // 更新列表总数和结构修改次数
 modCount++;
}

头插和尾插都只修改了一个引用，比较复杂的是在中间某个位置插入，其原理和代码如下：

// 在非null节点succ之前插入元素e
void linkBefore(E e, Node<E> succ) {
 // assert succ != null; 以下代码顺序不能变
 // 记住 succ 的前驱节点
 final Node<E> pred = succ.prev;
 // 1-2 创建一个新节点，它的前驱指向 pred，后继指向 succ
 final Node<E> newNode = new Node<>(pred, e, succ);
 // 3 succ 前驱指向新节点
 succ.prev = newNode;
 if (pred == null) // 如果是第一个节点
 first = newNode; // 让first也指向新节点
 else // 4 否则作为 pred 的后继节点
 pred.next = newNode;
 size++; // 元素总数加1
 modCount++; // 列表结构修改次数加1
}

2.2 删除节点

同样的删除也是分为从头或尾删除，头节点的删除，就是让 first 指向它的后继节点，代码如下：

private E unlinkFirst(Node<E> f) {
 // assert f == first && f != null;
 // 为了返回元素的数据
 final E element = f.item;
 // 临时变量引用头节点的后继节点
 final Node<E> next = f.next;
 // 释放头节点，全部至 null
 f.item = null;
 f.next = null; // help GC
 // 重置 first 引用
 first = next;
 // 如果删除的链表是最后一个节点
 if (next == null) 
 last = null;
 else // 头节点的前驱为 null
 next.prev = null;
 size--;
 modCount++;
 return element;
}

尾节点的删除，一样是修改 last 引用，让它指向它的前驱节点，与头节点删除逻辑差不多，可对照理解，代码如下：

private E unlinkLast(Node<E> l) {
 // assert l == last && l != null;
 final E element = l.item;
 final Node<E> prev = l.prev;
 l.item = null;
 l.prev = null; // help GC
 last = prev;
 if (prev == null)
 first = null;
 else
 prev.next = null;
 size--;
 modCount++;
 return element;
}

如果在某个中间位置删除，就需要正确的操作了，主要是防止在断链的过程中导致整个链条断开，代码如下：

E unlink(Node<E> x) {
 // assert x != null;
 final E element = x.item;
 // 待删除元素的前驱和后继节点
 final Node<E> next = x.next;
 final Node<E> prev = x.prev;
 if (prev == null) {
 // 链表为空
 first = next;
 } else {
 // 1 前驱节点的后继指向 x 的后继节点
 prev.next = next;
 x.prev = null;
 }
 if (next == null) {
 last = prev;
 } else {
 // 2 后继节点的前驱指向 x 的前驱节点
 next.prev = prev;
 x.next = null;
 }
 x.item = null;
 size--;
 modCount++;
 return element;
}

2.3 栈和队列

栈就是只能在栈顶操作，后进先出的受限线性表，LinkedList 提供的与栈相关的方法有：

• push(E e): 将元素插入栈顶，也就是插到列表的头，实际调用的是 linkFirst
• pop(): 从栈顶弹出一个元素，也就是删除并返回列表的第一个元素，实际调用的是 unlinkFirst
• peek(): 查看栈顶元素，不会删除
• peekFirst(),peekLast(): 分别是查看栈顶和栈尾元素

队列就是只能从一端插入，另一端删除的线性表，LinkedList 提供的与队列相关的方法：

• offer(E e): 入队列，将元素插入列表尾部，实际调用的是 linkLast
• offerFirst,offerLast: 分别是从头开始或从尾开始入队，当然了，确认在哪端就不要更改了
• remove(): 出队列，将列表头结点删除并返回
• removeFirst,removeLast: 与 offerFirst,offerLast 搭配使用

2.4 遍历

双链表有两种遍历方式：顺序遍历和逆序遍历，分别通过 ListItr 和 DescendingIterator 实现。同样这个 Iterator 也是快速失败的，其中 ListItr 分别提供了向前和向后的遍历方式，DescendingIterator 只是简单对 ListItr previous() 方法使用的封装，ListItr 核心代码如下：

private class ListItr implements ListIterator<E> {
 private Node<E> lastReturned = null;// 最后返回的节点
 private Node<E> next;// 下一个要读的节点
 private int nextIndex;// 下一个要读的节点位置
 // 缓存列表结构修改次数，检查并发修改
 private int expectedModCount = modCount;
 // 初始化开始遍历的位置，node(index) 会遍历找到这个节点
 ListItr(int index) {
 // assert isPositionIndex(index);
 next = (index == size) ? null : node(index);
 nextIndex = index;
 }
 // 顺序读时，判断是否还有更多的后继节点
 public boolean hasNext() {
 return nextIndex < size;
 }
 public E next() {
 checkForComodification();
 if (!hasNext())
 throw new NoSuchElementException();
 lastReturned = next;
 next = next.next; // 移动 next 指向其后继节点
 nextIndex++;
 return lastReturned.item;
 }
 // 逆序读时，判断是否还有更多的前驱节点
 public boolean hasPrevious() {
 return nextIndex > 0;
 }
 public E previous() {
 checkForComodification();
 if (!hasPrevious())
 throw new NoSuchElementException();
 // 移动 next 指向其前驱节点
 lastReturned = next = (next == null) ? last : next.prev;
 nextIndex--;
 return lastReturned.item;
 }
 public void remove() {
 // 遍历过程中，提供删除操作
 }
 public void add(E e) {
 // 遍历过程中，提供新增操作 
 }
 // 检查是否存在并发修改
 final void checkForComodification() {
 if (modCount != expectedModCount)
 throw new ConcurrentModificationException();
 }
}

3. 非线程安全

ArrayList 和 LinkedList 都是非线程安全的，那为什么呢？

ArrayList 本质操作可分为以下两类，这也是线程竞争条件的所在：

• 对 size 变量的操作，size++ 和 --size
• System.arraycopy() 数组拷贝

size++ 其实是一个复合操作：取值、加1和赋值，不是原子操作，非线程安全；System.arraycopy 它也是非线程安全的，所以 ArrayList 不是线程安全的。

LinkedList 主要竞争条件就是断链和续链的操作，以尾插为例，假如线程 A 执行:

final Node<E> l = last;
final Node<E> newNode = new Node<>(l, e, null);

如果现在线程 A 被抢占，线程 B 也执行相同的代码，并且继续执行：

last = newNode;

不久后，线程 A 也执行上述代码，那么问题就出来了，线程 B 完成操作后，线程 A 就操作了一次，导致线程 B 的要插入的节点丢失，所以不是线程安全的。

当然了 JDK 提供了 Collections.synchronizedList(List) 方法可以把 ArrayList 和 LinkedList 变成线程安全的。

4. 性能

ArrayList 具备数组随机访问的特性，但增加和删除需要移动数组元素，效率较慢。在动态扩容时，涉及到了内存拷贝，所以适当增加初始容量或者在添加大量数据之前提前扩大容量，减少拷贝次数是有必要的。

相比 ArrayList，LinkedList 只能顺序或逆序访问，占用的内存稍微大点，因为节点还要维护两个前后引用，但是它的插入删除效率高。

5. 小结

这两个是很常用的数据结构，也比较容易理解，在阅读源码时，jdk里类的设计，编码方式也值得重视。