LinkedList 源码分析

1. LinkedList 简介

ArrayList 是由双向链表实现的List，所以除了当做 List，还可以当做栈和队列来使用。    
	我们来看他的继承关系：

LinkedList 实现了 List 接口，拥有 List 接口的基础操作。     
LinkedList 实现了 Cloneable 接口，可以被克隆。                
LinkedList 实现了 Serializable 接口，可以被序列化。                        
LinkedList 实现了 Queue 和 DeQue 接口，可以作为双端队列使用。

2. 属性

    /**
     * 元素个数
     */
	transient int size = 0;

    /**
     * 链表头结点
     */
    transient Node<E> first;

    /**
     * 链表尾节点
     */
    transient Node<E> last;

3. Node 节点定义

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

4. 构造函数

    /**
     * 空列表构造函数
     */
    public LinkedList() {
    }
    
    /**
     * 非空列表
     */
    public LinkedList(Collection<? extends E> c) {
        this();
        addAll(c);
    }

5. 主要方法

    /**
     * 头插法添加元素。
     */
    private void linkFirst(E e) {
    	// 头节点
        final Node<E> f = first;
        // 创建新节点，新节点的 next 指针指向头结点， prev 指针置空。
        final Node<E> newNode = new Node<>(null, e, f);
        // 新节点作为头结点
        first = newNode;
        
        if (f == null)
            last = newNode;
        else
            f.prev = newNode;
        size++;
        // 修改次数加1，说明这是一个支持fail-fast的集合
        modCount++;
    }

    /**
     * 尾插法添加元素。
     */
    void linkLast(E e) {
    	// 尾节点
        final Node<E> l = last;
        // 新建节点 newNode，前趋节点为尾节点
        final Node<E> newNode = new Node<>(l, e, null);
        // 将新节点置为尾节点
        last = newNode;
        // 判断队列插入之前是否为空
        if (l == null)
        	// 为空则新节点也为头结点
            first = newNode;
        else
        	// 否则将 l 节点的 next 指针指向新节点
            l.next = newNode;
        // 列表大小+1
        size++;
        modCount++;
    }

    /**
     * 在非空节点 succ 之前插入新节点
     */
    void linkBefore(E e, Node<E> succ) {
        // assert succ != null;
        // 节点 pred 为 succ 节点的前趋节点，即为插入节点的前趋节点
        final Node<E> pred = succ.prev;
        // 新建节点，前趋节点为 pred，后继节点为 succ
        final Node<E> newNode = new Node<>(pred, e, succ);
        // succ 的前指针指向新节点
        succ.prev = newNode;
        // 判断 succ 是否为头结点
        if (pred == null)
        	// 新节点为头结点
            first = newNode;
        else
        	// 否则 pred 的 next 指针指向新节点
            pred.next = newNode;
        size++;
        modCount++;
    }

    /**
     * 删除头结点
     */
    private E unlinkFirst(Node<E> f) {
        // assert f == first && f != null;
        // 断言头结点非空
        // 首节点元素的值
        final E element = f.item;
        // 首节点的 next 节点
        final Node<E> next = f.next;
        // 首节点置空，方便 GC 回收
        f.item = null;
        f.next = null; // help GC
        // 头结点的 next 节点为头节点
        first = next;
        // 判断删除之后的列表是否为空
        if (next == null)
            last = null;
        else
            next.prev = null;
        size--;
        modCount++;
        return element;
    }

    /**
     * 删除尾节点
     */
    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;
        // 指定节点的 next 节点
        final Node<E> next = x.next;
        // 指定节点的 prev 节点
        final Node<E> prev = x.prev;
		// 判断指定节点的前趋节点是否为空
        if (prev == null) {
        	// 为空则指定节点的后继节点为头指针
            first = next;
        } else {
        	// 否则前趋节点的 next 指针指向 后继节点
            prev.next = next;
            // 断开 x 和前趋节点
            x.prev = null;
        }
		// 处理后继节点
        if (next == null) {
            last = prev;
        } else {
            next.prev = prev;
            x.next = null;
        }

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