Java | LinkedList源码分析

前言

LinkedList类是List接口的一种实现，它表示一个列表。同时，LinkedList类也是Deque接口的一种实现，所以它也可以表示一个双端队列。Deque接口除了提供操作双端队列的一系列方法之外，还提供了操作栈的方法，因此LinkedList还可以表示一个栈。ArrayList类也是List接口的一种实现，它是基于数组实现的。LinkedList是基于双向链表实现的。LinkedList与ArrayList一样，都是非线程安全的。

相关知识

• ArrayList源码分析
• LinkedList源码分析

源码分析

定义

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

LinkedList类继承于AbstractSequentialList类。AbstractSequentialList类提供了List接口的一个框架实现，以最小化实现这个支持“顺序访问”数据存储（例如链表）的接口所需的工作量。

LinkedList类实现了4个接口：

• List 列表接口，提供了操作列表的一系列方法，例如：add()、remove()、set()、get()等方法。
• Deque 双端队列接口，提供了操作双端队列和栈的一系列方法，例如：offerFirst()、offerLast()、pollFirst()、pollLast()、peekFirst()、peekLast()、push()、pop()等方法。
• Cloneable 可克隆标记接口，表示对象可以被克隆。
• Serializable 序列化标记接口，表示对象可以被序列化。

对于Deque接口，实际上它提供了两套操作双端队列的方法：

offer系列	add系列	方法描述
offerFirst()	addFirst()	将指定的元素插入到队首。
offerLast()	addLast()	将指定的元素添加到队尾。
pollFirst()	removeFirst()	取出并删除队首的元素。
pollLast()	removeLast()	取出并删除队尾的元素。
peekFirst()	getFirst()	取出队首的元素，但不删除。
peekLast()	getLast()	取出队尾的元素，但不删除。

它们的区别是：offer系列方法在操作失败时会返回一个特殊值（根据操作的不同，为false或者null）；add系列方法在操作失败时会抛出异常。

主要变量

transient Node<E> first;

transient Node<E> last;

transient int size = 0;

其中：

• first 链表的第一个节点。
• last 链表的最后一个节点。
• size 列表中包含的元素的个数。

列表的元素是存储在链表节点中的，链表节点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;
    }
}

其中：

• item 列表的元素。
• next 下一个节点。
• prev 上一个节点。

因此，LinkedList是基于 双向链表 实现的。

构造方法

public LinkedList() {
}

默认构造方法构造了一个空列表。

public LinkedList(Collection<? extends E> c) {
    this();
    addAll(c);
}

该构造方法构造了一个包含了指定集合元素的列表。

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

该add()方法将指定的元素添加到列表的末尾。add()方法直接调用了linkLast()方法。linkLast()方法新建了一个节点来存储元素，并将该节点链接到链表的末尾。最后更新了size变量。可以看出add()方法是支持null元素和重复元素的。

public void add(int index, E element) {
    checkPositionIndex(index);

    if (index == size)
        linkLast(element);
    else
        linkBefore(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;
    }
}

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

该add()方法将指定的元素添加到列表中指定的位置。首先调用checkPositionIndex()方法检查指定的位置索引的合法性。然后判断是将元素添加到列表的末尾还是插入到列表的其它位置。如果是将元素添加到列表的末尾，那么调用linkLast()方法将元素添加到列表的末尾。如果是将元素插入到列表的其它位置，那么先调用node()方法取出指定的位置索引处的节点，然后调用linkBefore()方法将指定的元素插入到指定的位置索引处的节点的前面。node()方法使用了一次二分查找，返回了指定的位置索引处的节点。linkBefore()方法新建了一个节点来存储元素，并将该节点链接到指定节点的前面。

remove()方法

public E remove(int index) {
    checkElementIndex(index);
    return unlink(node(index));
}

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

该remove()方法删除列表中指定位置的元素。首先调用checkElementIndex()方法检查指定的位置索引的合法性。然后调用node()方法取出指定的位置索引处的节点。最后调用unlink()方法删除指定的位置索引处的节点。

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()方法删除列表中第一个与指定元素相等的元素。如果列表中不包含与指定元素相等的元素，那么列表保持不变。remove()方法循环遍历链表，查找第一个存储元素与指定元素相等的节点。如果找到，那么调用unlink()方法删除存储该元素的节点。

set()方法

public E set(int index, E element) {
    checkElementIndex(index);
    Node<E> x = node(index);
    E oldVal = x.item;
    x.item = element;
    return oldVal;
}

set()方法将列表中指定位置的元素替换为指定的元素。首先调用checkElementIndex()方法检查指定的位置索引的合法性。然后调用node()方法取出指定的位置索引处的节点。接着将指定的位置索引处的节点中的元素替换为指定的新元素。最后返回旧元素。

get()方法

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

get()方法返回列表中指定位置的元素。首先调用checkElementIndex()方法检查指定的位置索引的合法性。然后调用node()方法取出指定的位置索引处的节点。最后返回指定的位置索引处的节点中的元素。

其它方法

理解了LinkedList的add()、remove()、set()、get()方法之后，其它方法就很好理解了。

总结

• LinkedList可以作为一个列表，也可以作为一个双端队列，还可以作为一个栈。
• LinkedList是基于双向链表实现的。
• LinkedList在查找元素时，需要遍历链表（有一次二分查找优化），因此查找元素效率低。
• LinkedList在列表中间插入或者删除元素时，不需要移动元素，因此插入或者删除元素效率高。
• LinkedList按照添加元素的顺序存储元素。
• LinkedList允许元素为null。
• LinkedList允许元素重复。
• LinkedList是非线程安全的。

参考

• https://docs.oracle.com/javase/8/docs/api/java/util/LinkedList.html