java中LRU算法

什么是LRU算法？

当我们处理大量数据时，经常需要使用缓存来提高性能。LRU（最近最少使用）算法是一种常用的缓存淘汰策略，用于在缓存空间不足时选择要删除的数据。

首先，我们需要了解LRU算法的工作原理。LRU算法的核心思想是基于数据的访问模式：最近被访问的数据很可能在不久的将来再次被访问，而最久未被访问的数据可能很快就会被废弃。LRU算法基于这个思想，将最近访问的数据保留在缓存中，而淘汰最久未被访问的数据。

用java实现LRU算法

基于Java中LinkedHashMap实现

在Java中，我们可以使用LinkedHashMap来实现LRU算法。LinkedHashMap是Java集合框架中的一个具体实现，它继承自HashMap，但是又以双向链表的形式维护元素的顺序。我们可以设置LinkedHashMap的访问顺序模式(accessOrder)为true，这样每次访问一个元素时，它会被放到最后。当缓存空间不足时，我们只需要删除链表头部的元素即可。

import java.util.LinkedHashMap;
import java.util.Map;

public class LRUCache<K, V> extends LinkedHashMap<K, V> {
    private final int capacity;
    public LRUCache(int capacity) {
        super(capacity, 0.75f, true);
        this.capacity = capacity;
    }
    @Override
    protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
        return size() > capacity;
    }
    public static void main(String[] args) {
        LRUCache<Integer, String> cache = new LRUCache<>(3);
        cache.put(1, "A");
        cache.put(2, "B");
        cache.put(3, "C");
        System.out.println(cache); // 输出：{1=A, 2=B, 3=C}        
        cache.get(2); // 访问key为2的元素
        System.out.println(cache); // 输出：{1=A, 3=C, 2=B}       
        cache.put(4, "D"); // 添加新的元素，触发删除最久未被访问的元素
        System.out.println(cache); // 输出：{3=C, 2=B, 4=D}
    }
}

我们创建了一个LRUCache类，继承自LinkedHashMap。在构造函数中，我们指定了缓存的容量。removeEldestEntry方法被重写，用于判断是否需要删除最久未被访问的元素。如果缓存超过容量，我们返回true，表示需要删除最老的元素。在main方法中，我们创建了一个容量为3的LRU缓存，进行了一些操作来展示LRU算法的工作机制。

基于自定义数据结构实现（HashMap+双向链表）

除了使用LinkedHashMap来实现LRU算法外，我们还可以通过自定义数据结构来实现。

一种常见的实现方式是使用哈希表和双向链表来构建LRU缓存。哈希表用于实现快速的数据查找，而双向链表用于维护数据的访问顺序。

class Node {
    int key;
    int value;
    Node prev;
    Node next;
    public Node(int key, int value) {
        this.key = key;
        this.value = value;
    }
}
public class LRUCache {
    private final int capacity;
    private final Map<Integer, Node> cache;
    private final Node head;
    private final Node tail;
    public LRUCache(int capacity) {
        this.capacity = capacity;
        this.cache = 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) {
        if (cache.containsKey(key)) {
            Node node = cache.get(key);
            removeNode(node);
            addToHead(node);
            return node.value;
        }
        return -1;
    }
    public void put(int key, int value) {
        if (cache.containsKey(key)) {
            Node node = cache.get(key);
            node.value = value;
            removeNode(node);
            addToHead(node);
        } else {
            if (cache.size() >= capacity) {
                Node tailNode = tail.prev;
                removeNode(tailNode);
                cache.remove(tailNode.key);
            }
            Node newNode = new Node(key, value);
            cache.put(key, newNode);
            addToHead(newNode);
        }
    }
    private void removeNode(Node node) {
        node.prev.next = node.next;
        node.next.prev = node.prev;
    }
    private void addToHead(Node node) {
        node.prev = head;
        node.next = head.next;
        head.next.prev = node;
        head.next = node;
    }
}

在上述代码中，我们定义了一个Node类来表示双向链表中的节点，包含上一个节点和下一个节点的引用，以及键值对的信息。LRUCache类包含一个哈希表cache用于快速查找节点，head和tail分别表示双向链表的头部和尾部。

在get方法中，如果缓存中存在键值对，则先从链表中移除该节点，然后将该节点插入到链表的头部，并返回节点的值。在put方法中，如果缓存中存在键值对，则更新该节点的值，并将该节点移到链表的头部。如果缓存已满，则移除链表尾部的节点，并从哈希表中删除相应的键值对。最后，将新节点插入到链表的头部，并将其存储到哈希表中。

这种方式使用哈希表和双向链表实现LRU算法，可以保持较好的时间复杂度。哈希表提供了O(1)的查找和删除操作，而双向链表保证了对最近访问的数据进行快速插入和移动的能力。