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里类的设计，编码方式也值得去重视。