JDK8：LinkedList源码分析

1.数据结构

LinkedList的底层数据结构是一个双向链表，但与大部分教材中的双向链表有些不同。

详细分析可参见这篇文章：linkedList中的双向链表JDK1.8

2.属性

		//记录LinkedList中节点的个数
		transient int size = 0;
		
	    //记录第一个节点
	    transient Node<E> first;

	    //记录最后一个节点
	    transient Node<E> last;

3.Node类

LinkedList的数据结构是一个双向链表，而链表都是由节点组成的，Node类就是描述节点的类。

结构图

源码

private static class Node<E> { 
		//如上图所示
        E item;
        Node<E> next;
        Node<E> prev;
		//有参构造，创建一个节点，比如是x，且x的prev指向prev这个节点，
		//x的next指向next这个节点，x的item是element
        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }

有参构造图解

在链表中插入节点的过程就是新节点与链表中节点建立链接的过程，假设要在第一个节点与第二节点之间新增一个节点。

第一步：

注意：上面那个节点用虚线，代表还没有创建，准备创建。

第二步：

当我们在创建Node类时，将上图中的m和n作为初始化参数，即这样写
Node< E> newNode = new Node<>(m, e, n); ，那么我们一次性就建立了两条链接。

注意：源码中增加节点就是用的这个逻辑。之后只用再建立两条链接，这个新节点就成功插入了，到这里已经明白了大半。

4.辅助方法

void linkFirst(E e)、 void linkLast(E e)、void linkBefore(E e, Node< E> succ)、E unlinkFirst(Node< E> f)、E unlinkLast(Node< E> l)、E unlink(Node< E> x)、和Node< E> node(int index) 这七个方法是实现LinkedList核心功能的基础。

例如：

public void addFirst(E e) {
        linkFirst(e);
    }

public E removeFirst() {
        final Node<E> f = first;
        if (f == null)
            throw new NoSuchElementException();
        return unlinkFirst(f);
    }

（1）void linkFirst(E e)

方法名要做到见名知意，那个这个方法的功能是：链接到第一个

源码

private void linkFirst(E e) {
		//用f记录第一个节点
        final Node<E> f = first;
        //创建一个新的节点，且调用的是有参构造，如图一
        final Node<E> newNode = new Node<>(null, e, f);
        //fist是用来记录第一个节点的，所以要变化，如图二
        first = newNode;
        if (f == null)
        	//若f为null，代表之前链表为空，
        	//那么新增一个节点后，该节点也是最后一个节点
            last = newNode;
        else
        	//图三
            f.prev = newNode;
        //节点个数加1
        size++;
        modCount++;
    }

图解

数无形时少直觉我们直接上图说明。

图一：

图二：

图三：

（2）void linkLast(E e)

链接到最后

源码

void linkLast(E e) {
        final Node<E> l = last;
        //图一
        final Node<E> newNode = new Node<>(l, e, null);
        //图二
        last = newNode;
        if (l == null)
            first = newNode;
        else
        	//图三
            l.next = newNode;
        //节点个数加1
        size++;
        modCount++;
    }

图解

图一：

图二：

图三：

（3）void linkBefore(E e, Node< E> succ)

在succ节点前插入一个节点

源码

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)
            first = newNode;
        else
        	//图三
            pred.next = newNode;
        //节点个数加1
        size++;
        modCount++;
    }

图解

图一：
图二：
图三：

注意：可以看出这个方法是在链表中间插入新节点的基础。

（4）E unlinkFirst(Node< E> f)

解除第一个节点的链接

源码

private E unlinkFirst(Node<E> f) {
        //如图一所示
        final E element = f.item;
        final Node<E> next = f.next;
        //这两行代码是方便垃圾回收器回收这个节点
        //图二
        f.item = null;
        f.next = null;
        //图三
        //first属性是用来记录链表第一个节点的，
        //当第一个节点删除后，first也要移动。
        first = next;
        if (next == null)
            last = null;
        else
        	//图四
            next.prev = null;
        //节点个数减1
        size--;
        modCount++;
        return element;
    }

图解

图一：

图二：

图三：

图四：

（5）E unlinkLast(Node< E> l)

解除最后一个节点的链接

源码

private E unlinkLast(Node<E> l) {
		//下面两行代码，如图一所示
        final E element = l.item;
        final Node<E> prev = l.prev;
        //下面三行代码，如图二
        l.item = null;
        l.prev = null;
        //last属性同理first属性
        last = prev;
        if (prev == null)
            first = null;
        else
        	//图三
            prev.next = null;
        size--;
        modCount++;
        return element;
    }

图解

图一：

图二：

图三：

（6）E unlink(Node x)

解决链表中间节点的链接

源码

E unlink(Node<E> x) {
        //下面三行代码，效果如图一
        final E element = x.item;
        final Node<E> next = x.next;
        final Node<E> prev = x.prev;

        if (prev == null) {
            first = next;
        } else {
        	//图二
            prev.next = next;
            x.prev = null;
        }

        if (next == null) {
            last = prev;
        } else {
        	//图三
            next.prev = prev;
            x.next = null;
        }
		//方便垃圾回收器回收
        x.item = null;
        size--;
        modCount++;
        return element;
    }

图解

图一：

图二：

图三：

（7）Node< E> node(int index)

定位方法，给出下标，帮你在链表找到这个节点

源码

Node<E> node(int index) {
        //“>> 1”相当于除以2
        //这是一个优化，说明JDK底层不会从头到尾遍历的，
        //而是用二分的思想，判断更靠近第一个节点first还是last
        if (index < (size >> 1)) {
        	//靠近第一个节点first，就从first开始往后遍历
            Node<E> x = first;
            for (int i = 0; i < index; i++)
                x = x.next;
            return x;
        } else {
        	//更靠近最后一个节点last，从last开始往前遍历
            Node<E> x = last;
            for (int i = size - 1; i > index; i--)
                x = x.prev;
            return x;
        }
    }