Java核心源码阅读之容器--LinkedList

概述

LinkedList是java Collections框架下的一个类，用双向链表实现，实现了List和Deque接口。实现了所有可选择的List操作，并且允许元素值为null。

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

LinkedList的实现是不同步的，当有多个线程访问并有至少一个线程修改结构（插入或删除元素）时，需要在外部实现同步。通常，可以通过对封装了该链表的对象实现同步。否则需要用Collections的synchronizedList类包装起来，例如：

List list = Collections.synchronizedList(new LinkedList(...));

当LinkedList的iterator被创建之后，修改链表的架构只能通过iterator的remove和add方法，否则会抛出ConcurrentModificationException异常。

成员变量

LinkedList涉及到的成员变量有链表大小size、头节点first和尾节点last。其中链表中的节点类型Node是一个静态内部类。

size

链表的长度

transient int size = 0;

first

双向链表的第一个元素。
若链表为空，则头节点和尾节点均为空，否则头节点不为空且头节点的前序节点为空，即(first == null && last == null) || (first.prev == null && first.item != null)

transient Node<E> first;

last

双向链表的最后一个元素。
若链表为空，则头节点和尾节点均为空，否则尾节点不为空且尾节点的后序节点为空，即(first == null && last == null) || (last.next == null && last.item != null)

transient Node<E> last;

静态内部类 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;
    }
}

构造方法

LinkedList有两个构造方法，一个是无参构造方法，创建一个空链表；一个是以Collection为参数，将Collection中的元素添加到链表中。

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

核心方法

clone

返回一个当前List的浅拷贝。拷贝了一个新的List，但List中元素本身并没有被拷贝。

public Object clone() {
    LinkedList<E> clone = superClone();

    // Put clone into "virgin" state
    clone.first = clone.last = null;
    clone.size = 0;
    clone.modCount = 0;

    // Initialize clone with our elements
    for (Node<E> x = first; x != null; x = x.next)
        clone.add(x.item);

    return clone;
}

List相关方法

get（时间复杂度O(n)）

获取指定index元素的值。因为使用链表存储，因此获取元素需要从头或者尾开始遍历寻找，比ArrayList要慢。
get方法中调用了node(index)方法，node(index)返回链表中的第index个节点，这里做了优化，若index在链表的前半部分，则从前向后遍历寻找元素，若index在链表的后半部分，则从后向前寻找元素。

public E get(int index) {
    //确认index合法性
    checkElementIndex(index);
    return node(index).item;
}
Node<E> node(int index) {
    // assert isElementIndex(index);
    //如果index在链表的前半部分
    if (index < (size >> 1)) {
        //从头节点向后遍历
        Node<E> x = first;
        for (int i = 0; i < index; i++)
            x = x.next;
        return x;
    } else {//index在链表的后半部分
        //从末节点向前遍历
        Node<E> x = last;
        for (int i = size - 1; i > index; i--)
            x = x.prev;
        return x;
    }
}

set（时间复杂度O(n)）

替换指定index的元素值。返回index原本的值。首先需要找到index位置的元素，再替换，因此时间复杂度为O(n)。

public E set(int index, E element) {
    //检查index是否合法
    checkElementIndex(index);
    //找到第index个元素
    Node<E> x = node(index);
    //替换新值
    E oldVal = x.item;
    x.item = element;
    return oldVal;
}

add（时间复杂度O(1)/O(n)）

在链表结尾或者链表指定index处插入元素。
在结尾插入节点仅需O(1)时间复杂度。
在指定index插入节点，因为需要先找到index的节点，再进行插入操作，因此时间复杂度为O(n)。

//在链表末尾插入元素
public boolean add(E e) {
    linkLast(e);
    return true;
}
//在链表指定位置插入元素
public void add(int index, E element) {
    checkPositionIndex(index);

    if (index == size)
        linkLast(element);
    else
        linkBefore(element, node(index));
}
//在链表结尾插入节点
void linkLast(E e) {
    final Node<E> l = last;
    //新建一个节点，前序节点为原来的last，后续为null
    final Node<E> newNode = new Node<>(l, e, null);
    //last节点更新为新建的节点
    last = newNode;
    //如果原本last节点为空，说明链表为空
    if (l == null)
        //指定链表头节点为新建节点
        first = newNode;
    //否则原来链表不为空
    else
        //把原本last节点的后继节点设为新建节点
        l.next = newNode;
    size++;
    modCount++;
}
//在succ节点前插入一个新节点
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;
    //如果前序节点为空（即succ为链表的头节点）
    if (pred == null)
        //将头节点设置为新的节点
        first = newNode;
    else
        pred.next = newNode;
    size++;
    modCount++;
}

remove（时间复杂度O(n)）

删除指定index的元素或是删除某个指定的元素。
删除指定index的元素首先需要找到第index个节点，再删除，寻找操作O(n)，删除操作O(1)，共需要O(n)。
删除某个指定的元素首先需要遍历链表找到相应链表中对应节点，再删除。寻找操作O(n)，删除操作O(1)，共需要O(n)。

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;
}
//删除Node x，并返回节点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;
    //若前序节点是空，即删除的节点x是头节点
    if (prev == null) {
        //则头节点变为x.next
        first = next;
    } else {
        prev.next = next;
        //把x的前序链接取消，有助于GC
        x.prev = null;
    }
    //若后序节点是空，即删除的节点是末节点
    if (next == null) {
        //则末节点变为x.prev
        last = prev;
    } else {
        next.prev = prev;
        //把x的后序节点取消，有助于GC
        x.next = null;
    }
    x.item = null;
    size--;
    modCount++;
    return element;
}

遍历

LinkedList除了用for遍历外，可用iterator进行遍历，速度比for循环快。因为for循环需要每次获取某个index的元素，而iterator直接获取链表的下一个节点即可。

Deque相关方法

由于LinkedList是用双向链表实现的，对于双端队列的操作比如插入、删除、获取头节点或者尾节点效率很高，均为O(1)的时间复杂度。

• getFirst()：获取链表头节点，为空则异常
• getLast()：获取链表尾节点，为空则异常
• addFirst()：链表头部插入节点
• addLast()：链表尾部插入节点
• removeFirst()：链表头部删除元素，为空则异常
• removeLast()：链表尾部删除元素，为空则异常
• peek()：获取链表头节点，为空则返回空
• peekFirst()：获取链表头节点，为空则返回空
• peekLast()：获取链表尾节点，为空则返回空
• element()：获取链表头节点，为空则异常
• poll()：删除并返回头节点，为空则返回空
• pollFirst()：删除并返回头节点，为空则返回空
• pollLast()：删除并返回尾节点，为空则返回空
• remove()：删除并返回头节点，为空则异常
• offer(E e)：链表尾部插入节点
• offerFirst(E e)：链表头部插入节点
• offerLast(E e)：链表尾部插入节点
• push(E e)：链表头部插入节点
• pop()：删除并返回头节点，为空则异常

总结

LinkedList用双向链表实现，实现了List和Deque接口，允许元素为null值，未实现同步。作为List，和ArrayList相比，插入操作更快（ArrayList涉及到扩容，移位置等操作），删除操作都为O(n)。get和set操作比较慢为O(n)，因为需要从链表头部或者尾部查找，而ArrayList仅为为O(1)。总体来讲，作为List，一般情况下选择ArrayList更优。