JDK1.7源码笔记之LinkedList类

1. class 简介

　　LinkedList是Java集合中常用的容器之一，内部是一个双向链表（不是循环的），实现了List和Deque接口，可以同时当作列表、队列和栈来使用，它提供了一系列对链表元素进行增删改查的方法，有很多功能差不多但名字不同的方法，有些针对空值抛异常而有些则返回特殊值，使用时最好将其上转型到相应的接口以限制它的功能。

2. class内部原理及特点

1. 不是线程安全的，没有Synchronized关键字。
2. 允许向其中添加null。
3. 内部是由一个一个的内部类Node前后指针连接组成的链，LinkedList相当于一个Node的管理类（如下图所示），有两根指针first和last一直指向Node链的头部和尾部，其优势在于增加和删除元素较快，但不适合查找操作。
4. 其迭代器是快速失败的，在一个LinkedList的迭代器创建之后调用非迭代器中的方法对容器的内部结构进行修改都会抛出ConcurrentModificationException。
   

3. class源码细节分析

　　对双向链表的操作无非就是对几根指针进行玩耍，LinkedList中方法有不少，但是功能相同的很多，只是针对空值或者没有元素的情况做出的反应不同。针对不同的接口，应该使用名字相关的方法，比如将LinkedList当队列来使用时应该使用带有offer，poll，peek等名字的方法，当成栈来使用时应该使用带有push，peek，pop等名字的方法，以增加可读性。
　　LinkedList的所有增删改查方法基本上都和底层这几个方法有关：linkFirst, linkLast, linkBefore, unlinkFirst, unlinkLast, unlink, node。

linkFirst和linkLast

/* 头插法 */
private void linkFirst(E e) {
    final Node<E> f = first;
    //创建一个新结点，其前指针为空，后指针指向first所指结点（可能为null）
    final Node<E> newNode = new Node<>(null, e, f);
    first = newNode;//first指针始终指向Node链的头
    if (f == null)   //如果LinkedList刚创建，此时新创建的结点既然是头结点也是尾结点
        last = newNode;
    else
        f.prev = newNode;//如果头插之前有结点，将其前指针指向新结点
    size++;
    modCount++;//记录修改次数，迭代时检测快速失败
}
/* 尾插法 */
void linkLast(E e) {//操作和头插相反
    final Node<E> l = last;
    //创建一个新结点，其后指针为空，前指针指向last所指结点（可能为null）
    final Node<E> newNode = new Node<>(l, e, null);
    last = newNode;//last指针始终指向Node链的尾
    if (l == null)  //如果LinkedList刚创建，此时新创建的结点既然是尾结点也是头结点
        first = newNode;
    else
        l.next = newNode;//如果尾插之前有结点，将其后指针指向新结点
    size++;
    modCount++;
}

linkBefore

/* 在指定结点前插入 */
void linkBefore(E e, Node<E> succ) {
    final Node<E> pred = succ.prev;
    //创建一个新结点，其前指针指向指定结点的前驱，后指针指向指定结点的后继
    final Node<E> newNode = new Node<>(pred, e, succ);
    succ.prev = newNode;//指定结点的前指针连上新结点
    if (pred == null)//LinkedList刚创建
        first = newNode;
    else
        pred.next = newNode;//指定结点的前驱结点的后指针连上新结点
    size++;
    modCount++;
}

unlinkFirst, unlinkLast和unlink

/* 删除头结点 */
private E unlinkFirst(Node<E> f) {//这个f必须是头结点
    final E element = f.item;
    final Node<E> next = f.next;
    f.item = null;
    f.next = null; // 标记一下有利于垃圾回收
    first = next;//first指针始终指向头结点
    if (next == null)//LinkedList刚创建
        last = null;
    else
        next.prev = null;//next此时为头结点
    size--;
    modCount++;
    return element;
}
/* 删除尾结点 */
private E unlinkLast(Node<E> l) {//l必须是尾结点
    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) {//LinkedList刚创建时
        first = next;
    } else {
        prev.next = next;//前驱连接上后继
        x.prev = null;//删除
    }

    if (next == null) {//LinkedList刚创建时
        last = prev;
    } else {
        next.prev = prev;//后继连接上前驱
        x.next = null;//删除
    }

    x.item = null;
    size--;
    modCount++;
    return element;
}

node

/* 查找双向链表从头结点往尾结点数的第index个结点 */
Node<E> node(int index) {
    if (index < (size >> 1)) {//如果index小于链表总长度的一半，则从头往尾找
        Node<E> x = first;
        for (int i = 0; i < index; i++)
            x = x.next;
        return x;
    } else {              //如果index大于链表总长度的一半，则从尾往头找
        Node<E> x = last;
        for (int i = size - 1; i > index; i--)
            x = x.prev;
        return x;
    }
}

４. 总结　　

　　LinkedList是常用的java集合之一。当要频繁地进行插入和删除操作时，使用LinkedList效果较好，尽量不要对其进行查找的操作。LinkedList既可以当列表使用，还可以充当队列和栈，使用时最好将其上转型到相应的接口以限制它的功能。