Java数据结构—链表（Linked List）

链表是一种线性数据结构，由链表节点组成，每个节点包含一个值和指向下一个节点的引用。链表中的元素不必在内存中相邻，因此插入和删除操作较为高效。

Java代码实现链表需要定义一个节点类，其中包含一个值和一个指向下一个节点的引用。创建链表时，需要指定头节点并在其后面添加新节点。我们可以使用while循环遍历整个链表并执行所需的操作。

以下是一个示例：创建一个链表来存储整数并打印它们。首先定义节点类：

class ListNode {
    int val;
    ListNode next;

    public ListNode(int val) {
        this.val = val;
    }
}

然后创建链表并添加元素：

ListNode head = new ListNode(1);
head.next = new ListNode(2);
head.next.next = new ListNode(3);
head.next.next.next = new ListNode(4);

最后，我们可以使用while循环打印链表中的元素：

ListNode current = head;
while (current != null) {
    System.out.println(current.val);
    current = current.next;
}

一个使用链表的示例是LRU Cache（最近最少使用缓存）。LRU Cache是一种常见的缓存算法，它根据元素最近访问的时间来删除最少使用的元素。我们可以使用双向链表来实现LRU Cache。

以下是一个示例：实现一个LRU Cache，使用HashMap来快速访问和更新缓存，使用双向链表来按最近访问时间排序元素。

class LRUCache {
    class Node {
        int key;
        int value;
        Node prev;
        Node next;

        public Node(int key, int value) {
            this.key = key;
            this.value = value;
        }
    }

    private int capacity;
    private Map<Integer, Node> map;
    private Node head;
    private Node tail;

    public LRUCache(int capacity) {
        this.capacity = capacity;
        this.map = new HashMap<>();
        this.head = new Node(0, 0);
        this.tail = new Node(0, 0);
        head.next = tail;
        tail.prev = head;
    }

    public int get(int key) {
        Node node = map.get(key);
        if (node == null) {
            return -1;
        }
        remove(node);
        add(node);
        return node.value;
    }

    public void put(int key, int value) {
        Node node = map.get(key);
        if (node != null) {
            node.value = value;
            remove(node);
            add(node);
        } else {
            if (map.size() == capacity) {
                map.remove(tail.prev.key);
                remove(tail.prev);
            }
            Node newNode = new Node(key, value);
            map.put(key, newNode);
            add(newNode);
        }
    }

    private void add(Node node) {
        Node next = head.next;
        head.next = node;
        node.prev = head;
        node.next = next;
        next.prev = node;
    }

    private void remove(Node node) {
        node.prev.next = node.next;
        node.next.prev = node.prev;
    }
}

总结：链表是一种线性数据结构，由链表节点组成，每个节点包含一个值和指向下一个节点的引用。Java代码实现链表需要定义一个节点类并使用while循环遍历整个链表。链表在插入和删除操作上比数组更高效，并且可以用于实现LRU Cache等算法和数据结构。