LinkedList源码解析（jdk1.8）

本篇介绍的LinkedList是List接口的另一种实现，它的底层是基于双向链表实现的，它具有插入删除快而查找修改慢的特点，此外，通过对双向链表的操作还可以实现队列和栈的功能。

一、类的继承

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable

二、类的属性

//集合size
transient int size = 0;
//头结点
transient Node<E> first;
//尾结点
transient Node<E> last;

LinkedList的底层结构如下图所示：

F表示头结点引用，L表示尾结点引用，链表的每个结点都有三个元素，分别是前继结点引用(P)，结点元素的值(E)，后继结点的引用(N)。结点由内部类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;
        }
    }

Node这个内部类只有三个成员变量和一个构造器，item表示结点的值，next为下一个结点的引用，prev为上一个结点的引用，通过构造器传入这三个值。

三、构造函数

    public LinkedList() {
    }
    public LinkedList(Collection<? extends E> c) {
        this(); //先调用无参构造期
        addAll(c);//调用add函数
    }

有两个构造器，一个是无参构造器，一个是传入外部集合的构造器。与ArrayList不同的是LinkedList没有指定初始大小的构造器。

四、add函数

1、在了解add方法之前，我们先了解LinkedList中linkLast(E)／linkBefore(E, Node<E>) ，这两个方法是增加节点的方法：

a、linkLast方法总结就是：获取最后一个节点，如果为空则新节点就是第一个节点，否则新节点就是当前集合最后一个节点的下一个节点。代码如下：

    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;
        size++;
        modCount++;
    }

b、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) //如果给定结点的上一个结点为空, 表明给定结点为头结点，将头结点引用指向新结点
            first = newNode;
        else //否则, 将给定结点的上一个结点的下一个结点引用指向新结点
            pred.next = newNode;
        size++;
        modCount++;
    }

2、下面是关于add函数的几个方法：

	//方法1：在当前集合最后面加一个节点
    public boolean add(E e) {
        linkLast(e);
        return true;
    }

    //方法2：根据下标在指定位置插入函数
    public void add(int index, E element) {
        checkPositionIndex(index); //检查下标是否越界
        if (index == size)
            linkLast(element);
        else
            linkBefore(element, node(index)); //node(index)：返回指定位置的node，详细见下
    }

    //方法3：当前集合新增集合结果
    public boolean addAll(Collection<? extends E> c) {
        return addAll(size, c); //将集合改成数组，然后循环利用node的属性新增集合元素（节点）
    }

add(int index, E element)调用了node(index)，代码如下：

   Node<E> node(int index) {
        if (index < (size >> 1)) { //如果下标在链表前半部分, 就从头开始查起
            Node<E> x = first;
            for (int i = 0; i < index; i++)
                x = x.next;
            return x;
        } else { //如果下标在链表后半部分, 就从尾开始查起
            Node<E> x = last;
            for (int i = size - 1; i > index; i--)
                x = x.prev;
            return x;
        }
    } 

总结：
1、node(index)其实就是根据下标，然后循环依次获取下个节点（或上个节点，二分法），获得最红节点；

2、add函数其实就是插入的时候，如果有指定的下标位置，那么将后面的节点往后移一位，如果没有指定下标位置就直接在链表最后新增一个节点。

五、remove函数

	//根据下标删除
    public E remove(int index) {
        checkElementIndex(index);
        return unlink(node(index));
    }
    //删除指定元素
    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;
    }

remove函数找到删除元素之后，调用了方法 unlink(Node) 进行节点删除，它的代码如下：

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节点为给定节点的前一个节点（倒数第二个）
            last = prev;
        } else { //将下一个结点的前继结点引用指向给定结点的前继结点
            next.prev = prev;
            x.next = null; //将给定结点的下一个结点置空
        }

        x.item = null; //将节点元素设置为空
        size--;
        modCount++;
        return element;
    }

总结：remove函数第一步找到要删除的元素，第二步则处理集合元素的要删除节点的上个节点和下个节点；

六、get/set函数

	    //查询，根据下标获取，调用node(index)
    public E get(int index) {
        checkElementIndex(index);
        return node(index).item;
    }
    //修改， 先查询到节点，然后更换节点的元素
   public E set(int index, E element) {
        checkElementIndex(index);
        Node<E> x = node(index);
        E oldVal = x.item;
        x.item = element;
        return oldVal;
    }

总结：对链表的查找和修改操作都需要遍历链表进行元素的定位，所以效率会低一点；

七、实现队列和栈的操作
队列：是一种特殊的线性表，特殊之处在于它只允许在表的前端进行删除操作，而在表的后端进行插入操作。（先进先出）
栈：又名堆栈，它是一种运算受限的线性表，其限制是仅允许在表的一端进行插入和删除运算。（先进后出）
LinkedList数据结构是基于链表的，所以通过对双向链表的操作还可以实现单项队列，双向队列和栈的功能。

不管是单向队列还是双向队列还是栈，其实都是对链表的头结点和尾结点进行操作，它们的实现都是基于addFirst()，addLast()，removeFirst()，removeLast()这四个方法，它们的操作和linkBefore()和unlink()类似，只不过一个是对链表两端操作，一个是对链表中间操作。可以说这四个方法都是linkBefore()和unlink()方法的特殊情况。

八、总结
1、LinkedList是基于双向链表实现的，不论是增删改查方法还是队列和栈的实现，都可通过操作结点实现
2、LinkedList无需提前指定容量，因为基于链表操作，集合的容量随着元素的加入自动增加
3、LinkedList删除元素后集合占用的内存自动缩小，无需像ArrayList一样调用trimToSize()方法
4、LinkedList的所有方法没有进行同步，因此它也不是线程安全的，应该避免在多线程环境下使用

参考博客：点击打开链接