LinkedList 笔记整理

基于 Java 8

---

概述

截图自：
https://lrh1993.gitbooks.io/android_interview_guide/content/java/basis/linkedlist.html

---

部分内容及方法

以链表的形式来存储元素，节点结构为：

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 包含两个成员变量

/**
 * 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;

first 用于指向第一个节点，last 用于执行最后一个节点。且 first 和 last 分别满足注释中的条件。

---

基础方法

// 将元素插入到最前面
private void linkFirst(E e) {
    final Node<E> f = first;
    final Node<E> newNode = new Node<>(null, e, f);
    first = newNode;
    // 如果原 first 为 null，则表示原来没有元素，则 last 也指向新加的元素
    if (f == null)
        last = newNode;
    // 否则，将原 first 排到第二
    else
        f.prev = newNode;
    size++;
    modCount++;
}

// 将元素插入到最后面
void linkLast(E e) {
    final Node<E> l = last;
    final Node<E> newNode = new Node<>(l, e, null);
    last = newNode;
    // 如果原 last 为 null，则表示原来没有元素，则 first 也指向新加的元素
    if (l == null)
        first = newNode;
    // 否则，将原 last 排到倒数第二
    else
        l.next = newNode;
    size++;
    modCount++;
}

// 根据 index 得到对应的 node
Node<E> node(int index) {
    // assert isElementIndex(index);
    
    // 如果 index < size/2，则从头开始遍历
    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;
    }
}

// 得到元素 e 对应的节点插入到 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;
    if (pred == null)
        first = newNode;
    else
        pred.next = newNode;
    size++;
    modCount++;
}

// 从链表中删除节点 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;
}

/**
 * Tells if the argument is the index of an existing element.
 */
// 判断 index 是否属于 [0, size)，这里不包括 size
// 该方法用于 set、get、remove 方法中来检查目标 index 是否处于有效范围
private boolean isElementIndex(int index) {
    return index >= 0 && index < size;
}

/**
 * Tells if the argument is the index of a valid position for an
 * iterator or an add operation.
 */
 // 判断 index 是否属于 [0, size]，这里包括 size
 // 该方法用于 add、listIterator 方法中来检查目标 index 是否处于有效范围
private boolean isPositionIndex(int index) {
    return index >= 0 && index <= size;
}

常用方法

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

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

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

public E get(int index) {
	// 先检查 index 是否在范围内
    checkElementIndex(index);
    return node(index).item;
}

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

// 移除指定 index 对应的节点
public E remove(int index) {
    checkElementIndex(index);
    return unlink(node(index));
}

上述常用方法则基于前面的基础方法来实现的。

public void clear() {
    // Clearing all of the links between nodes is "unnecessary", but:
    // - helps a generational GC if the discarded nodes inhabit
    //   more than one generation
    // - is sure to free memory even if there is a reachable Iterator
    for (Node<E> x = first; x != null; ) {
        Node<E> next = x.next;
        x.item = null;
        x.next = null;
        x.prev = null;
        x = next;
    }
    first = last = null;
    size = 0;
    modCount++;
}

clear() 方法并不是简单的将 first、last 置为 null，还会将每个节点的 prev、next，以及存储元素的 item 都置为 null，从而有利于垃圾回收。