JDK 8 LinkedList 详解及详细源码展示

原创已于 2025-06-24 22:44:51 修改 · 479 阅读

3 ·

CC 4.0 BY-SA版权

文章标签：

#JDK8 #源码 #学习

于 2025-06-22 08:03:59 首次发布

源码学习专栏收录该内容

118 篇文章

订阅专栏

JDK 8 `LinkedList` 详解

Java 8 中的 LinkedList 是一个基于双向链表实现的列表，它同时实现了 List 和 Deque 接口，支持高效的插入、删除操作。下面我将详细解析 LinkedList 的核心概念、实现原理和源码。

一、核心概念

1. 数据结构

双向链表：内部使用节点（Node）存储元素，每个节点包含前驱、后继和元素值。

2. 关键参数

size：链表中元素的数量。
first：链表的头节点。
last：链表的尾节点。

3. 特点

优点：插入/删除效率高（O(1)），适合频繁增删的场景。
缺点：随机访问效率低（O(n)），需遍历链表。

二、源码解析

1. 节点结构

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

2. 类定义与成员变量

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
    transient int size = 0;           // 链表大小
    transient Node<E> first;          // 头节点
    transient Node<E> last;           // 尾节点

    public LinkedList() {
    }

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

3. 添加元素（尾部插入）

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++;  // 记录结构修改次数
}

4. 指定位置插入元素

public void add(int index, E element) {
    checkPositionIndex(index);  // 检查索引是否合法

    if (index == size)
        linkLast(element);      // 如果插入位置是尾部，直接调用linkLast
    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;
    }
}

// 在指定节点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++;
}

5. 删除元素

public E remove(int index) {
    checkElementIndex(index);  // 检查索引是否合法
    return unlink(node(index));  // 解除节点链接并返回元素值
}

// 解除节点链接
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;  // 帮助GC
    }

    if (next == null) {
        last = prev;  // 如果后继为空，前驱成为尾节点
    } else {
        next.prev = prev;
        x.next = null;  // 帮助GC
    }

    x.item = null;  // 帮助GC
    size--;
    modCount++;
    return element;
}

6. 获取元素

public E get(int index) {
    checkElementIndex(index);  // 检查索引是否合法
    return node(index).item;   // 返回指定索引位置的元素
}

7. 实现Deque接口的方法

// 作为队列（Queue）的操作
public E peek() {
    final Node<E> f = first;
    return (f == null) ? null : f.item;
}

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

// 作为双端队列（Deque）的操作
public void addFirst(E e) {
    linkFirst(e);
}

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

// 作为栈（Stack）的操作
public E pop() {
    return removeFirst();
}

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