Java集合之LinkedList

对于LinkedList来说，其基本特性如下：

基本特性	结论
元素是否允许为null	是
元素是否允许重复	是
是否有序	是
是否线程安全	否

与ArrayList是一致的。

源码分析

本文使用的是JDK 1.8.0_201的源码。

成员变量

LinkedList是基于链表实现的，并且是双向链表结构。LinkedList类的主要成员变量：

成员变量	作用
transient int size = 0;	集合中元素的个数
transient Node first;	头结点
transient Node last;	尾结点

Node类表示链表的一个节点，它是LinkedList的一个静态内部类。既然LinkedList是双向链表，那么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;
    }
}

添加元素操作

前面文章讲过ArrayList是由数组实现的，它在添加元素时，如果数组长度不够了，那么会对数组进行扩容。LinkedList不需要进行扩容，因为采用的链表结构，只需要新增一个节点，并将引用赋值给原链表最后一个节点的next属性。

单向链表的话，这么做就够了，但是LinkedList是一个双向链表，因此必须同时维护头结点和尾结点，稍微会复杂一些。我们来看下JDK 1.8 具体是怎么实现的：

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

这里逻辑还是比较简单的，可以看到，当LinkedList第一次添加元素时，first节点会指向这个元素节点。

LinkedList添加元素的方法除了上面继承自List的add()方法，还有继承自Deque的addFirst()、addLast()、push()和offer()。由于篇幅的问题，这里我们只分析继承自List接口的方法，关于Deque接口的方法，逻辑也是很简单的，知道就行了。

删除操作

前面讲过ArrayList的删除操作效率不高，而基于链表结构的LinkedList删除操作效率要高一些。与ArrayList相同的是，LinkedList也支持按照下标进行删除与按照元素进行删除两种方式，这两种方式最终都是调用unlink()方法进行删除，我们来看看unlink()方法：

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

从这里可以发现，链表的删除操作之所以效率比较高，是因为删除时，只会影响相邻元素的引用，而不会像数组那样需要移动其后所有的元素。

对于删除操作，LinkedList还有继承自Deque接口的poll()、pop()、removeFirst()和removeLast()等等方法。

插入元素操作

插入操作的逻辑与前面按照下标进行删除的逻辑相似，只不过一个是删除元素，一个是插入元素。关键代码如下：

void linkBefore(E e, Node<E> succ) {
    // assert succ != null;
    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++;
}

查找元素操作

对于ArrayList来说，get()操作的时间复杂度为O(1)，而LinkedList的get()操作时间复杂度为O(n)。很明显，在随机查找方面，ArrayList效率更高。我们来看下LinkedList是怎么实现get()操作的：

public E get(int index) {
    checkElementIndex(index);
    return node(index).item;
}

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

算法的逻辑是在node()中实现的，由于if (index < (size >> 1)) 这条语句，LinkedList的get()操作时间复杂度实际上应该为O(n/2)。

LinkedList和ArrayList的对比

既然Java集合类中有LinkedList和ArrayList这两个类，那么在日常使用过程中，他们俩肯定有不同的使用场景。

在 Java集合之ArrayList 这篇文章中已经分析过ArrayList的优缺点，现在来总结下LinkedList的优缺点：

• LinkedList的优点是性能稳定，它的删除和插入操作都只需要改变前后相邻元素的引用地址，而对于ArrayList，插入和删除操作需要移动前后所有元素，如果被操作的元素位置靠前，那么需要移动的元素就会非常多。
• LinkedList的缺点是双向链表结构势必会占用更多的内存，新建节点需要的操作更多，并且内存地址也不是连续的，势必在顺序访问的时候，效率要比ArrayList低。随机访问时的效率也比ArrayList低。

从上面的分析来看，如果使用场景中有较多的删除和插入操作，那么建议使用LinkedList。