Java(day62)：深入探秘：Java 中的 LinkedList 详解与实战-CFANZ编程社区

前言

在上一期内容中，我们重点探讨了 Java 集合框架中的 ArrayList，从它的底层实现到实际应用，再到性能优化和注意事项，都进行了全面剖析。而当我们深入了解 ArrayList 时，不免会产生一个疑问：面对频繁的插入和删除操作时，有没有更优的选择？答案就是今天的主角——LinkedList。

相比于 ArrayList，LinkedList 的结构和应用场景截然不同，它在某些场景下可以展现出无可替代的性能优势。今天，我们将通过深入解析 LinkedList 的底层实现、核心方法和应用场景，带你全面了解这个常被低估却极具价值的数据结构。

摘要

本文以 Java 中的 LinkedList 为主线，从概述到源码解析，从使用案例到应用场景，从优缺点分析到核心方法介绍，再到测试用例实现，层层递进地展示 LinkedList 的方方面面。通过本文，你将掌握以下内容：

LinkedList 的底层实现原理。
在实际开发中的高效使用方法及注意事项。
适合 LinkedList 的典型应用场景及其性能优势。
如何通过测试用例验证 LinkedList 的行为和性能。

无论你是初学者还是经验丰富的开发者，都能从中找到对自己有价值的内容。

概述

什么是 LinkedList？

LinkedList 是 Java 集合框架中的一个双向链表实现类，位于 java.util 包下。它实现了 List、Deque 和 Queue 接口，既可以作为线性列表（List）使用，也可以作为队列（Queue）和双端队列（Deque）使用。

与 ArrayList 不同，LinkedList 的底层基于 双向链表（Doubly Linked List），每个节点都包含三个部分：

当前节点存储的数据。
指向前一个节点的引用（prev）。
指向后一个节点的引用（next）。

这种结构使得 LinkedList 在插入和删除操作上效率更高，但在随机访问（如通过索引访问元素）时性能较低。

关键特性

动态性：无需预定义容量，插入和删除时会动态调整内存。
插入与删除高效：在链表中操作节点时，只需调整指针即可。
存储不连续：与数组不同，链表的节点可以分布在内存中的任意位置。
支持双端操作：作为 Deque 接口的实现类，LinkedList 支持从两端进行插入和删除。

适用场景

LinkedList 的特性决定了它在以下场景中表现出色：

需要频繁插入和删除元素时。
需要模拟队列（FIFO）或双端队列（Deque）时。
需要按顺序遍历而无需随机访问时。

源码解析

LinkedList 的源码结构精巧，接下来我们将从核心类定义、关键成员变量和重要方法三个方面对其进行解析。

1. 核心类定义

public class LinkedList<E> extends AbstractSequentialList<E>
                          implements List<E>, Deque<E>, Cloneable, java.io.Serializable {
    // 构造函数
    public LinkedList() {}
    
    public LinkedList(Collection<? extends E> c) {
        this();
        addAll(c);
    }
}

LinkedList 继承了 AbstractSequentialList，并实现了 List、Deque 和 Cloneable 等接口，具备丰富的功能。

2. 关键成员变量

LinkedList 的核心是节点类 Node<E>，每个节点保存数据和指向前后节点的引用：

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 还包含以下两个指针：

first：指向链表的第一个节点。
last：指向链表的最后一个节点。

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

在指定位置插入元素：

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

    if (index == size)
        linkLast(element);
    else
        linkBefore(element, node(index));
}

删除元素

删除第一个元素：

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

删除指定位置的元素：

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

遍历元素

使用迭代器：

public Iterator<E> iterator() {
    return new ListItr(0);
}

通过这些方法，我们可以看出 LinkedList 的操作本质上是对链表节点的增删查改。

使用案例分享

1. 模拟队列操作

import java.util.LinkedList;

public class QueueExample {
    public static void main(String[] args) {
        LinkedList<String> queue = new LinkedList<>();

        // 入队
        queue.addLast(A);
        queue.addLast(B);
        queue.addLast(C);

        // 出队
        System.out.println(queue.removeFirst()); // 输出: A
        System.out.println(queue.removeFirst()); // 输出: B
    }
}

2. 实现双端队列

import java.util.LinkedList;

public class DequeExample {
    public static void main(String[] args) {
        LinkedList<Integer> deque = new LinkedList<>();

        // 从头部插入
        deque.addFirst(10);
        deque.addFirst(20);

        // 从尾部插入
        deque.addLast(30);

        // 从头部和尾部移除
        System.out.println(deque.removeFirst()); // 输出: 20
        System.out.println(deque.removeLast()); // 输出: 30
    }
}

3. 使用 LinkedList 模拟 LRU 缓存

import java.util.LinkedList;

public class LRUCache {
    private LinkedList<Integer> cache;
    private int capacity;

    public LRUCache(int capacity) {
        this.capacity = capacity;
        this.cache = new LinkedList<>();
    }

    public void access(int item) {
        if (cache.contains(item)) {
            cache.remove((Integer) item);
        } else if (cache.size() == capacity) {
            cache.removeLast();
        }
        cache.addFirst(item);
    }

    public void display() {
        System.out.println(cache);
    }

    public static void main(String[] args) {
        LRUCache lru = new LRUCache(3);
        lru.access(1);
        lru.access(2);
        lru.access(3);
        lru.access(2);
        lru.access(4);
        lru.display(); // 输出: [4, 2, 3]
    }
}

应用场景案例

频繁插入和删除的列表：如任务调度队列。
模拟队列或栈：如浏览器历史记录或打印任务队列。
链式数据结构：如 LRU 缓存。

优缺点分析

优点

动态扩展性强。
插入和删除操作效率高。
支持队列和双端队列操作。

缺点

随机访问性能差，时间复杂度为 O(n)。
占用更多的内存空间（存储指针）。

核心类方法介绍

方法	描述
`add(E e)`	在链表末尾添加元素。
`addFirst(E e)`	在链表头部插入元素。
`removeFirst()`	删除并返回链表第一个元素。
`get(int index)`	获取指定索引的元素。
`iterator()`	返回链表的迭代器。

测试用例

import org.junit.Test;
import static org.junit.Assert.*;
import java.util.LinkedList;

public class LinkedListTest {

    @Test
    public void testAddAndRemove() {
        LinkedList<String> list = new LinkedList<>();
        list.add(A);
        list.add(B);
        list.add(C);

        assertEquals(A, list.removeFirst());
        assertEquals(C, list.removeLast());
    }

    @Test
    public void testGet() {
        LinkedList<Integer> list = new LinkedList<>();
        list.add(10);
        list.add(20);
        list.add(30);

        assertEquals((Integer) 20, list.get(1));
    }
}

小结

通过本文的学习，我们全面解析了 Java 中 LinkedList 的核心特性及其应用场景，了解了它的优缺点和适用场景。通过源码解析和测试用例，我们更加清晰地理解了其内部原理和实际操作。

总结

LinkedList 是 Java 集合框架中不可或缺的一部分，尽管它的性能在随机访问上不及 ArrayList，但在特定场景下，它的灵活性和高效性无可替代。掌握 LinkedList 的使用不仅能帮助我们优化代码性能，还能拓宽对数据结构的理解深度。希望本文能让你对 LinkedList 有更深入的认知，为你的开发工作提供助力！