LinkedList源码分析

一、目标

同学，很高兴与您相遇！通过该文章，我希望能达到几个目标：

      1、能更深刻的理解LinkedList

      2、能在工作或者面试中帮到您

      3、将我所学能很好的分享给您

二、介绍

LinkedList是一个非线程安全的集合；同时也实现了Deque，是支持FIFO原则的；其内部采用的是双向链表的数据结构存储元素的，可支持保存null元素。

三、源码分析

源码分析的话，这章节我们就分析add、get、remove就可以了；像getFirst、getLast、removeFirst这方法只要明白了其原理，也是很容易明白是怎么回事的。

图3.1

在图3.1中画的就是linkedList的双向链表的数据结构，prev_node上一个节点，node是当前节点，next_node是下一个节点；从图中可以看出linkedList是由node组成，每一个node都有两个指针分别指向上一个node和下一个node。

    transient int size = 0;

    /**
     * Pointer to first node.
     * Invariant: (first == null && last == null) ||
     *            (first.prev == null && first.item != null)
     */
    transient Node<E> first;

    /**
     * Pointer to last node.
     * Invariant: (first == null && last == null) ||
     *            (last.next == null && last.item != null)
     */
    transient Node<E> last;

• size ： 当前集合的大小
• first ： 第一个node节点
• last ： 最后一个node节点

这里的first和last是当前对象的全局变量，当添加元素的时候，就会计算该两个变量的值到底指向哪一个node节点；从add方法就很清楚的看出这是怎么回事了。

1、add方法

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

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

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

add方法内部其实是调用了linkLast方法的；当第一次添加add("node1")的时候，成员变量last是为null的，故而 final Node<E> l 局部变量也是为null；接着final Node<E> newNode = new Node<>(l, e, null);这里就是将当前的元素放到Node进行初始化，每一个node内部都维护了一个双向链表的数据结构；然后将成员变量last指向新增的元素，以此同时判断“l”局部变量是否为null，如果为null则成员变量first就指向当前新增的元素，否则将l.next指向当前的新增的元素；最后就是size++自增操作；modCount是指当前对象修改的次数，目前了解到的只有在Iterator相关操作的时候才会使用到。其实理解add的方法逻辑时候，对着图3.1来看应该很容易明白是怎么回事的。

2、get方法

    public E get(int index) {
        checkElementIndex(index);
        return node(index).item;
    }
    /**
     * Returns the (non-null) Node at the specified element index.
     */
    Node<E> node(int index) {
        // assert isElementIndex(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;
        }
    }

checkElementIndex(index)主要是检查是否出现下标越界，有就抛出IndexOutOfBoundsException异常；在node()方法中是通过二分查找的方式，这样查询速度会快一些；从源码删过来看的话，是循环获取元素直到循环到对应元素的位置才停止；从这里可以看出，LinkedList在数据量一大的情况下获取元素的时候性能是很慢的，就是因为需要循环到对应的index才可以停止循环，估计这也是为什么要使用二分查找的方式了；

• 二分查找
• 循环获取元素直到循环到指定的index位置
• 查询性能慢

3、remove方法

    public E remove(int index) {
        checkElementIndex(index);
        return unlink(node(index));
    }
    /**
     * Unlinks non-null node x.
     */
    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) {
            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;
    }

刚进来就是检查checkElementIndex是否下标越界；然后主要是看unlink方法，这个方法主要是改变当前元素的next和prev指针指向，同时将当前的元素x.item、x.next和x.prev（这item、next、prev所在Node对象里面维护的）置为null。下面用图3.3.1并结合代码来讲这个过程，应该会比较容易理解

图3.3.1

node就是代表当前即将要删除的元素；此时会判断node节点中的prev是否为null，如果为null则将成员变量first指向next_node，如果不为null则将prev.next指向next_node节点，此时就改变了node节点中prev指向了；继续下去就是判断node节点中的next，如果next为null则将成员变量last指向prev_node，如果不为null则将next.prev指向prev_node节点；然后会将node节点中的item、prev和next置为null；最后将当前删除的元素return回去。

• 主要是理解node节点中prev和next的指向逻辑就OK了

四、结论

到目前为止，已经将LinkedList的add、get和remove方法分析完了。至于刚开头说的getFirst、getLast、removeFirst这些方法大致都是围绕成员变量的first和last节点来操作的（排除特殊的方法，具体还是得看源码是怎么实现的）。通过这几个方法，对LinkedList做一些总结：

• 对新增、删除操作速度是很快的；只需要改变node里面的prev和next就可以了；
• 通过下标index来get元素的时候，效率是很慢的；因为需要不断循环直到循环到指定的index；这里就没有ArrayList方便了
• 使用的是双向链表，这也决定了它添加元素的时候是允许为null的；添加null元素的时候，可以通过size可以分辨出来是否添加进去了。
• getFirst、getLast效率是很看的，因为只需要直接操作成员变量first和last就可以了，不需要循环去获取
• 从源码来看LinkedList是非线程安全的
• 添加的元素是有序的

 

以上内容如有问题，希望可以留言给我，我可以及时纠正。很高兴与您相遇，希望对阅读完后对您有所帮助；

学习永无止境，不进则退~！