LRU算法的Java实现

1. 什么是LRU

LRU（Least Recently Used）算法是一种常用的缓存淘汰策略，用于在缓存空间不足时决定哪些数据应该被淘汰出去。

LRU算法的基本思想是：当缓存空间已满时，淘汰最近最少使用的数据。具体实现方式可以使用一个数据结构（如双向链表）和一个哈希表来辅助实现。

以下是LRU算法的一般实现步骤：

• 1. 创建一个固定大小的缓存空间（如数组或链表）和一个哈希表。
• 2. 当需要访问数据时，首先在哈希表中查找数据是否存在：
     • 如果数据存在于缓存中，表示数据已经被访问过，将其从当前位置移动到缓存的头部，表示最新访问过。
     • 如果数据不存在于缓存中，表示数据未被缓存，需要从数据源获取，并将其添加到缓存的头部。
• 3. 当缓存空间已满时，需要淘汰数据：
     • 淘汰最近最少使用的数据，即缓存尾部的数据，这是因为尾部的数据表示最久未被访问。
     • 同时，在哈希表中删除相应的数据项。

LRU算法通过将最近访问的数据放在缓存的头部，而最久未访问的数据放在缓存的尾部，实现了数据的淘汰策略。这样可以保证在缓存空间有限时，较少使用的数据会被淘汰，从而为更常用的数据腾出空间。

2. JAVA实现

import java.util.HashMap;
import java.util.Map;

class LRUCache {
    private int capacity;
    private Map<Integer, Node> cache;
    private Node head;
    private Node tail;

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

    public int get(int key) {
        Node node = cache.get(key);
        if (node != null) {
            // 将该节点移到链表头部表示最近使用
            moveToHead(node);
            return node.value;
        }
        return -1;
    }

    public void put(int key, int value) {
        Node node = cache.get(key);
        if (node != null) {
            // 更新节点值，并将该节点移到链表头部表示最近使用
            node.value = value;
            moveToHead(node);
        } else {
            if (cache.size() == capacity) {
                // 移除最近最少使用的节点（尾部节点）
                Node tailNode = removeTail();
                cache.remove(tailNode.key);
            }
            // 创建新节点，并将其插入到链表头部
            Node newNode = new Node(key, value);
            cache.put(key, newNode);
            addToHead(newNode);
        }
    }

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

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

    private void moveToHead(Node node) {
        removeNode(node);
        addToHead(node);
    }

    private Node removeTail() {
        Node tailNode = tail.prev;
        removeNode(tailNode);
        return tailNode;
    }

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

        public Node() {
        }

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

public class Main {
    public static void main(String[] args) {
        LRUCache cache = new LRUCache(2);

        cache.put(1, 1);
        cache.put(2, 2);
        System.out.println(cache.get(1)); // 输出 1

        cache.put(3, 3);
        System.out.println(cache.get(2)); // 输出 -1

        cache.put(4, 4);
        System.out.println(cache.get(1)); // 输出 -1
        System.out.println(cache.get(3)); // 输出 3
        System.out.println(cache.get(4)); // 输出 4
    }
}