Java集合类学习--LinkedList

概述

LinkedList 内部是一个双向链表，并且实现了 List 接口和 Deque 接口，因此它也具有 List 的操作以及双端队列和栈的性质。双向链表的结构如下：

LinkedList 的继承结构如下：

源码分析

重要部分
1、结点类 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 类则是链表的结点。
2、成员变量

// 元素个数
transient int size = 0;
// 链表首节点
transient Node<E> first;
// 链表尾节点
transient Node<E> last;

构造方法
LinkedList 有两个构造器，如下：

//无参
public LinkedList() {
}
//有参，使用addAll方法
public LinkedList(Collection<? extends E> c) {
    this();
    addAll(c);
}

PS: 由于链表的容量可以一直增加，因此没有指定容量的构造器。

跟进addAll（）方法

public boolean addAll(Collection<? extends E> c) {
    return addAll(size, c);
}

public boolean addAll(int index, Collection<? extends E> c) {
    checkPositionIndex(index);
    // 将集合元素转为数组
    Object[] a = c.toArray();
    int numNew = a.length;
    if (numNew == 0)
        return false;
    // 获取当前链表的前驱和后继结点
    Node<E> pred, succ;
    if (index == size) { 
    //当在链表最后插入时，last变为前节点，后继节点为空.
        succ = null;
        pred = last;
    } else { 
    //在当前节点的前面插入整个数组.
        succ = node(index);
        pred = succ.prev;
    }
    // 循环将数组中的元素插入到链表
    for (Object o : a) {
        @SuppressWarnings("unchecked") E e = (E) o;
        Node<E> newNode = new Node<>(pred, e, null);
        if (pred == null)
            first = newNode;
        else
            pred.next = newNode;
        pred = newNode;
    }
    // 若插入到末尾，则数组中的最后一个元素就是尾结点
    if (succ == null) {
        last = pred;
    } else {
        // 若插入到指定位置，将数组中最后一个元素与下一个位置关联起来
        pred.next = succ;
        succ.prev = pred;
    }
    size += numNew;
    modCount++;
    return true;
}

其中 node(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;
    }
}

node(index)方法并非直接从头到尾遍历整个链表，而是先判断下标的位置，若在前一半则从前往后遍历；否则就从后往前遍历。这样能减少遍历结点的个数。

重要方法

1、新增结点方法：add(), addLast(), offerLast()，addFirst(), offerFirst()

public void addFirst(E e) {
    linkFirst(e);
}

public boolean offerFirst(E e) {
        addFirst(e);
        return true;
    }
public boolean offerLast(E e) {
    addLast(e);
    return true;
}

public void addLast(E e) {
    linkLast(e);
}

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

跟进方法可以发现，其实内部他们都是调用了同一个方法 linkLast(e) 和linkFirst实现的，如下：

	// 从队列尾添加元素
   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 void linkFirst(E e) {
    // 首节点
    final Node<E> f = first;
    // 创建新节点，新节点的next是首节点
    final Node<E> newNode = new Node<>(null, e, f);
    // 让新节点作为新的首节点
    first = newNode;
    // 判断是不是第一个添加的元素
    // 如果是就把last也置为新节点
    // 否则把原首节点的prev指针置为新节点
    if (f == null)
        last = newNode;
    else
        f.prev = newNode;
    // 元素个数加1
    size++;
    // 修改次数加1，说明这是一个支持fail-fast的集合
    modCount++;
}

因为是链表特性，还需要在中间位置添加元素，则是使用add()l另外方法

// 在指定index位置处添加元素
public void add(int index, E element) {
    // 判断是否越界
    checkPositionIndex(index);
    // 如果index是在队列尾节点之后的一个位置
    // 把新节点直接添加到尾节点之后
    // 否则调用linkBefore()方法在中间添加节点
    if (index == size)
        linkLast(element);
    else
        linkBefore(element, node(index));
}

跟进linkBefore（），可以发现，在调用linkBefore时也是用了获取当前节点位置的node方法。

// 在节点succ之前添加元素
void linkBefore(E e, Node<E> succ) {
    // succ是待添加节点的后继节点
    // 找到待添加节点的前置节点
    final Node<E> pred = succ.prev;
    // 在其前置节点和后继节点之间创建一个新节点
    final Node<E> newNode = new Node<>(pred, e, succ);
    // 修改后继节点的前置指针指向新节点
    succ.prev = newNode;
    // 判断前置节点是否为空
    // 如果为空，说明是第一个添加的元素，修改first指针
    // 否则修改前置节点的next为新节点
    if (pred == null)
        first = newNode;
    else
        pred.next = newNode;
    // 修改元素个数
    size++;
    // 修改次数加1
    modCount++;
}

2、删除结点方法：poll(), pollFirst(), removeFirst()，pollLast(), removeLast()

public E poll() {
    final Node<E> f = first;
    return (f == null) ? null : unlinkFirst(f);
}

public E pollFirst() {
    final Node<E> f = first;
    return (f == null) ? null : unlinkFirst(f);
}

public E removeFirst() {
    final Node<E> f = first;
    if (f == null)
        throw new NoSuchElementException();
    return unlinkFirst(f);
}

public E removeLast() {
    final Node<E> l = last;
    if (l == null)
        throw new NoSuchElementException();
    return unlinkLast(l);
}

public E pollLast() {
    final Node<E> l = last;
    return (l == null) ? null : unlinkLast(l);
}

可以看到，最终实现也都是unlink开头的一些方法：

// 删除首节点
private E unlinkFirst(Node<E> f) {
    // 首节点的元素值
    final E element = f.item;
    // 首节点的next指针
    final Node<E> next = f.next;
    // 添加首节点的内容，协助GC
    f.item = null;
    f.next = null; // help GC
    // 把首节点的next作为新的首节点
    first = next;
    // 如果只有一个元素，删除了，把last也置为空
    // 否则把next的前置指针置为空
    if (next == null)
        last = null;
    else
        next.prev = null;
    // 元素个数减1
    size--;
    // 修改次数加1
    modCount++;
    // 返回删除的元素
    return element;
}
// 删除尾节点
private E unlinkLast(Node<E> l) {
    // 尾节点的元素值
    final E element = l.item;
    // 尾节点的前置指针
    final Node<E> prev = l.prev;
    // 清空尾节点的内容，协助GC
    l.item = null;
    l.prev = null; // help GC
    // 让前置节点成为新的尾节点
    last = prev;
    // 如果只有一个元素，删除了把first置为空
    // 否则把前置节点的next置为空
    if (prev == null)
        first = null;
    else
        prev.next = null;
    // 元素个数减1
    size--;
    // 修改次数加1
    modCount++;
    // 返回删除的元素
    return element;
}
// 删除指定节点x
E unlink(Node<E> x) {
    // x的元素值
    final E element = x.item;
    // x的前置节点
    final Node<E> next = x.next;
    // x的后置节点
    final Node<E> prev = x.prev;
    
    // 如果前置节点为空
    // 说明是首节点，让first指向x的后置节点
    // 否则修改前置节点的next为x的后置节点
    if (prev == null) {
        first = next;
    } else {
        prev.next = next;
        x.prev = null;
    }

    // 如果后置节点为空
    // 说明是尾节点，让last指向x的前置节点
    // 否则修改后置节点的prev为x的前置节点
    if (next == null) {
        last = prev;
    } else {
        next.prev = prev;
        x.next = null;
    }

    // 清空x的元素值，协助GC
    x.item = null;
    // 元素个数减1
    size--;
    // 修改次数加1
    modCount++;
    // 返回删除的元素
    return element;
}

向单链表插入和删除结点的操作示意图如下（双链表比这里多了前驱结点）：

作为栈使用时，入栈（push）和出栈（pop）操作：

public void push(E e) {
    addFirst(e);
}

public E pop() {
    return removeFirst();
}

添加删除元素都只操作队列首节点即可。