JDK1.8源码阅读（六）：LinkedList

一、初识LinkedList

LinkedList类图设计

• LinkedList实现了Cloneable接口，意味着它能被克隆；
• LinkedList实现了java.io.Serializable接口，意味着 它支持序列化；
• LinkedList继承了AbstractSequentialList，从Sequential这个单词可以看出，该抽象类实现的是顺序访问的结构，这和链表有关；
• LinkedList实现了Deque这个接口，这个类名字的由来是“double ended queue”，也就是双向队列，即从头部和尾部都可以进行队列的操作。

综上，LinkedList是一个双向链表的数据结构。

二、源码阅读

1、成员变量

// list中的元素个数
transient int size = 0;
// 链表的头节点
transient Node<E> first;
// 链表的尾节点
transient Node<E> last;

2、构造函数

// 无参构造函数
public LinkedList() {
}
// 传入一个集合的构造函数
public LinkedList(Collection<? extends E> c) {
  // 调用无参数的构造方法
  this();
  // 将c集合里的元素添加进list
  addAll(c);
}

public boolean addAll(Collection<? extends E> c) {
  return addAll(size, c);
}

public boolean addAll(int index, Collection<? extends E> c) {
  // 检查index是否在正确
  checkPositionIndex(index);
  // 将collection转为数组
  Object[] a = c.toArray();
  int numNew = a.length;
  if (numNew == 0)
    return false;
  // pred为前置元素， succ为后继元素
  Node<E> pred, succ;
  // 对pred，succ进行初始化。
  if (index == size) {
    // index == size，说明要插入元素的位置就在链表的末尾，后置元素为null，前一个元素就是last
    succ = null;
    pred = last;
  } else {
    // index != size， 说明在链表的中间插入，这是pred为原来index的prev，succ为原来的元素
    succ = node(index);
    pred = succ.prev;
  }
  // 遍历数组，逐个添加
  for (Object o : a) {
    @SuppressWarnings("unchecked") E e = (E) o;
    Node<E> newNode = new Node<>(pred, e, null);
    if (pred == null)
      first = newNode;
    else
      pred.next = newNode;
    pred = newNode;
  }

  // 如果后继元素为空，那么插入完后的最后一个元素就是pred
  // 前面for循环添加，pred指向了newNode，即c的最后一个元素
  if (succ == null) {
    last = pred;
  } else {
  	// 如果后继元素不为空，pred.next为后继元素，后继元素的上个元素为pred
    pred.next = succ;
    succ.prev = pred;
  }
  
  size += numNew;
  modCount++;
  return true;
}

由于采用的是链表结构，所以LinkedList不像ArrayList一样，有指定容量的构造方法。

• 按照前-自己-后的关系调用Node的构造方法，进行初始化。
• 由于可能存在前一个元素pred为空的可能（构造函数调用），判断pred为空，则初始化的元素就是头节点
• 否则就维护pred与新节点newNode直接的关系。
• 将新节点作为pred，为下一个元素插入做准备

3、add(E e)方法

public boolean add(E e) {
  linkLast(e);
  return true;
}

void linkLast(E e) {
  // 记录last节点
  final Node<E> l = last;
  // 初始化新的节点
  final Node<E> newNode = new Node<>(l, e, null);
  last = newNode;
  // 对last节点进行判断
  if (l == null)
    first = newNode;
  else
    l.next = newNode;
  // 元素数量+1
  size++;
  // 添加修改次数
  modCount++;
}

4、remove(Object o)

public boolean remove(Object o) {
  // 是否为空的判断
  if (o == null) {
    // 遍历链表寻找元素
    for (Node<E> x = first; x != null; x = x.next) {
      if (x.item == null) {
        // 重新维护删除元素的前后元素的关系
        unlink(x);
        return true;
      }
    }
  } else {
    for (Node<E> x = first; x != null; x = x.next) {
      if (o.equals(x.item)) {
        // 重新维护删除元素的前后元素的关系
        unlink(x);
        return true;
      }
    }
  }
  return false;
}

E unlink(Node<E> x) {
  final E element = x.item;
  // 记录前后元素
  final Node<E> next = x.next;
  final Node<E> prev = x.prev;
  // prev为null说明x节点为first节点，则删除后，next为first
  if (prev == null) {
    first = next;
  // 否则 prev的下一个元素为x的next
  } else {
    prev.next = next;
    // 设为null，方便prev的GC
    x.prev = null;
  }
  // 同上
  if (next == null) {
    last = prev;
  } else {
    next.prev = prev;
    // 设为null，方便next的GC
    x.next = null;
  }
  // 设为null，方便GC
  x.item = null;
  size--;
  modCount++;
  return element;
}

三、总结

对于在集合中间进行频繁的插入和删除操作，或者需要使用队列特性的时候，我们可以考虑选用LinkedList。