Java设计一个实现LRU缓存淘汰算法的数据结构

实现一个LRU（Least Recently Used）缓存机制，需要在构造函数中传入缓存的最大容量 capacity，并支持以下两个操作：

• int get(key) - 如果密钥（key）存在于缓存中，则获取密钥的值，否则返回-1。
• void put(key, value) - 如果密钥不存在，则把（key、value）这个键值对存入缓存中，当存储达到上限时，LRU缓存淘汰掉最近最少使用的键值对。

import java.util.HashMap;

class LRUCache {
    class DLinkedNode {
        int key;
        int value;
        DLinkedNode prev;
        DLinkedNode next;
    }

    private void addNode(DLinkedNode node) {
        node.prev = head;
        node.next = head.next;

        head.next.prev = node;
        head.next = node;
    }

    private void removeNode(DLinkedNode node) {
        DLinkedNode prev = node.prev;
        DLinkedNode next = node.next;

        prev.next = next;
        next.prev = prev;
    }

    private void moveToHead(DLinkedNode node) {
        removeNode(node);
        addNode(node);
    }

    private DLinkedNode popTail() {
        DLinkedNode res = tail.prev;
        removeNode(res);
        return res;
    }

    private HashMap<Integer, DLinkedNode> cache = new HashMap<Integer, DLinkedNode>();
    private int size;
    private int capacity;
    private DLinkedNode head, tail;

    public LRUCache(int capacity) {
        this.size = 0;
        this.capacity = capacity;

        head = new DLinkedNode();
        tail = new DLinkedNode();

        head.next = tail;
        tail.prev = head;
    }

    public int get(int key) {
        DLinkedNode node = cache.get(key);
        if (node == null) return -1;

        moveToHead(node);

        return node.value;
    }

    public void put(int key, int value) {
        DLinkedNode node = cache.get(key);

        if(node == null) {
            DLinkedNode newNode = new DLinkedNode();
            newNode.key = key;
            newNode.value = value;

            cache.put(key, newNode);
            addNode(newNode);

            ++size;

            if(size > capacity) {
                DLinkedNode tail = popTail();
                cache.remove(tail.key);
                --size;
            }
        } else {
            node.value = value;
            moveToHead(node);
        }
    }
}

 该代码实现了一个LRU缓存淘汰算法的数据结构。其中，使用了双向链表和哈希表的结合方式来实现缓存的存储和查找，并按照LRU缓存淘汰算法将最近最少使用的缓存条目淘汰掉。LRU算法可以保证缓存中只存储最常使用的条目，降低了空间复杂度，并能够提升查询效率。