Java LinkedList 使用和实现原理

Java LinkedList 是 Java 标准类库中的一个常用数据结构，它是基于链表实现的可变长度的动态列表。相比于 ArrayList，LinkedList 具有快速插入和删除、节省内存等优势，因此在 Java 开发中也被广泛应用。本文将深入探讨 Java LinkedList 的原理，包括实现方式、内部结构、常用方法等，并附上代码和图示说明。

一、Java LinkedList 的实现方式

Java LinkedList 的实现方式是基于双向链表的动态列表，它在内部维护了一个节点类 Node，用于存储列表中的元素。每个节点都包含一个前驱指针 prev 和一个后继指针 next，用于指向前一个节点和后一个节点。在初始化时，LinkedList 会创建一个空的链表，即头尾节点都为 null。在添加元素时，LinkedList 会创建一个新的节点，并将它插入到链表的末尾。在删除元素时，LinkedList 会将指定节点的前驱指针和后继指针分别指向彼此，从而完成节点的删除。

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
    // 链表的头节点
    transient Node<E> first;

    // 链表的尾节点
    transient Node<E> last;

    // 链表中元素的数量
    transient int size;

    // 构造函数
    public LinkedList() {
    }

    // 添加元素到链表末尾
    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 E remove(int index) {
        checkElementIndex(index);
        return unlink(node(index));
    }

    // 链接节点到链表末尾
    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++;
    }

    // 链接节点到指定位置的前面
    void linkBefore(E e, Node<E> succ) {
        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++;
    }

    // 删除指定节点
    E unlink(Node<E> x) {
        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--;
        return element;
    }
}

二、Java LinkedList 的内部结构

Java LinkedList 内部维护了一个 Node 类型的双向链表，用于存储列表中的元素。每个节点都包含一个前驱指针 prev 和一个后继指针 next，用于指向前一个节点和后一个节点。在添加元素时，LinkedList 会创建一个新的节点，并将它插入到链表的末尾。在删除元素时，LinkedList 会将指定节点的前驱指针和后继指针分别指向彼此，从而完成节点的删除。

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

三、Java LinkedList 的常用方法

Java LinkedList 提供了许多常用方法，如添加元素、删除元素、获取元素等。下面将介绍其中的几个重要的方法。

add(E e)：添加元素

add() 方法用于在列表的末尾添加元素。该方法会创建一个新的节点，并将它插入到链表的末尾。该方法返回一个 boolean 类型的值，表示是否添加成功。

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

add(int index, E element)：添加元素到指定位置

add() 方法还提供了一个可以将元素添加到指定位置的重载版本。该方法会在指定位置前插入一个新的节点，并将该节点的前驱指针和后继指针分别指向前一个节点和后一个节点。

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

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

remove(int index)：删除指定位置的元素

remove() 方法用于删除指定位置的元素。该方法会将指定节点的前驱指针和后继指针分别指向彼此，从而完成节点的删除。该方法返回被删除的元素。

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

get(int index)：获取指定位置的元素

get() 方法用于获取指定位置的元素。该方法会遍历链表，找到指定位置的节点，并返回该节点的元素。

public E get(int index) {
    checkElementIndex(index);
    return node(index).item;
}

四、Java LinkedList 的应用场景

Java LinkedList 在开发中被广泛应用，特别是在需要频繁插入和删除元素的场景中。下面列举了几个常见的应用场景。

队列

LinkedList 可以用作队列的实现，通过 add() 方法将元素添加到队列的末尾，通过 remove() 方法从队列的头部删除元素，从而实现队列的先进先出（FIFO）功能。

Queue<String> queue = new LinkedList<>();
queue.add("a");
queue.add("b");
queue.add("c");
queue.remove();

栈

LinkedList 也可以用作栈的实现，通过 addFirst() 方法将元素添加到栈顶，通过 removeFirst() 方法从栈顶删除元素，从而实现栈的后进先出（LIFO）功能。

Deque<String> stack = new LinkedList<>();
stack.addFirst("a");
stack.addFirst("b");
stack.addFirst("c");
stack.removeFirst();

迭代器

LinkedList 实现了 List 接口和 Deque 接口，因此可以通过迭代器遍历列表中的元素。通过迭代器，可以实现对列表元素的快速遍历和操作。

List<String> list = new LinkedList<>();
list.add("a");
list.add("b");
list.add("c");
Iterator<String> it = list.iterator();
while (it.hasNext()) {
    String s = it.next();
    System.out.println(s);
}

五、总结

Java LinkedList 是基于双向链表实现的可变长度的动态列表，它具有快速插入和删除、节省内存等优势。在实际开发中，LinkedList 应用广泛，特别是在需要频繁插入和删除元素的场景中。本文介绍了 LinkedList 的实现方式、内部结构、常用方法和应用场景，希望对读者理解 LinkedList 的原理和使用有所帮助。