在Java实现通用 LinkedList

简介

LinkedList是Java语言中非常常见的可变列表（List）的实现之一。LinkedList可以用来存储任何类型的元素，比如整数、字符串、自定义对象等等。在Java中，LinkedList是基于双向链表的数据结构实现的。

通过实现自己的LinkedList，我们可以更好地理解Java中的链表数据结构，并且为以后的程序开发提供了一个通用的数据结构。

实现步骤

1. 定义节点类

首先，我们需要定义一个链表节点类，该类必须包含以下成员变量：

• value：表示节点存储的值
• prev：表示链表中当前节点的前一个节点
• next：表示链表中当前节点的下一个节点

public class Node<E> {
    E value;
    Node<E> prev;
    Node<E> next;
    
    public Node(E value) {
        this.value = value;
    }
}

在上面的代码中，我们定义了一个泛型类型E作为节点存储的值类型。

2. 定义LinkedList类

接下来，我们需要定义一个LinkedList类，该类必须包含以下成员变量和方法：

• head：表示链表中的头节点
• tail：表示链表中的尾节点
• size：表示链表中的节点个数
• addFirst(element)：在链表的头部添加一个元素
• addLast(element)：在链表的尾部添加一个元素
• removeFirst()：从链表的头部删除一个元素
• removeLast()：从链表的尾部删除一个元素
• clear()：清空链表
• toString()：将链表转换为字符串

public class LinkedList<E> {
    private Node<E> head;
    private Node<E> tail;
    private int size;
    
    public void addFirst(E element) {
        Node<E> node = new Node<>(element);
        if (size == 0) {
            head = tail = node;
        } else {
            node.next = head;
            head.prev = node;
            head = node;
        }
        size++;
    }
    
    public void addLast(E element) {
        Node<E> node = new Node<>(element);
        if (size == 0) {
            head = tail = node;
        } else {
            node.prev = tail;
            tail.next = node;
            tail = node;
        }
        size++;
    }
    
    public E removeFirst() {
        if (size == 0) {
            throw new NoSuchElementException();
        }
        E value = head.value;
        if (head == tail) {
            head = tail = null;
        } else {
            head = head.next;
            head.prev = null;
        }
        size--;
        return value;
    }
    
    public E removeLast() {
        if (size == 0) {
            throw new NoSuchElementException();
        }
        E value = tail.value;
        if (head == tail) {
            head = tail = null;
        } else {
            tail = tail.prev;
            tail.next = null;
        }
        size--;
        return value;
    }
    
    public void clear() {
        head = tail = null;
        size = 0;
    }
    
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        Node<E> node = head;
        while (node != null) {
            sb.append(node.value);
            if (node.next != null) {
                sb.append(", ");
            }
            node = node.next;
        }
        sb.append("]");
        return sb.toString();
    }
}

在上面的代码中，我们使用泛型类型E来表示存储在链表中的元素类型。我们通过定义Node类和LinkedList类，实现了一个通用的双向链表数据结构。

测试示例

下面是一个简单的示例，演示如何使用我们实现的LinkedList类来存储字符串元素，并在控制台上输出链表中的元素：

public static void main(String[] args) {
    LinkedList<String> list = new LinkedList<>();
    list.addLast("Alice");
    list.addLast("Bob");
    list.addLast("Charlie");
    System.out.println(list.toString());
    // 输出：[Alice, Bob, Charlie]

    list.removeLast();
    System.out.println(list.toString());
    // 输出：[Alice, Bob]
}

总结

在本文中，我们介绍了如何在Java中实现一个通用的双向链表。我们首先定义了一个节点类，然后使用该节点类定义了一个链表类，该链表类包含了常用的增删改查操作。通过实现一个通用的LinkedList，我们可以更好地理解Java中的链表数据结构，并且为我们的程序开发提供了一个通用的数据结构。