Java 实现 LRU 算法详解

在计算机科学中，LRU（Least Recently Used）算法即最近最少使用算法，是一种常用的页面置换算法，在缓存管理等场景中有广泛应用。本文将详细介绍如何使用 Java 实现 LRU 算法。

一、LRU 算法概述

LRU 算法的核心思想是，如果一个数据在最近一段时间没有被访问到，那么在将来它被访问的可能性也很小。当缓存空间已满时，最久没有被访问的数据将被淘汰，为新的数据腾出空间。

二、Java 实现 LRU 算法的思路

1. 使用双向链表来存储数据，这样可以方便地进行节点的插入和删除操作。
2. 维护一个哈希表，用于快速查找链表中的节点。
3. 当访问一个数据时，将其对应的节点移动到链表头部，表示它是最近被访问的。
4. 当插入一个新数据时，如果缓存已满，删除链表尾部的节点，然后将新节点插入到链表头部。

三、具体实现步骤

1. 定义双向链表节点类

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

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

2. 定义 LRU 缓存类

import java.util.HashMap;

class LRUCache {
    private int capacity;
    private HashMap<Integer, Node> map;
    private Node head;
    private Node tail;

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

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

    public void put(int key, int value) {
        if (map.containsKey(key)) {
            Node node = map.get(key);
            node.value = value;
            remove(node);
            insert(node);
        } else {
            if (map.size() == capacity) {
                Node last = tail.prev;
                remove(last);
                map.remove(last.key);
            }
            Node node = new Node(key, value);
            insert(node);
            map.put(key, node);
        }
    }

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

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

四、测试 LRU 缓存

以下是一个简单的测试用例：

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
    }
}

在这个测试用例中，我们创建了一个容量为 2 的 LRU 缓存。首先，我们插入两个键值对 (1, 1) 和 (2, 2)。然后，我们访问键为 1 的值，这将把节点 (1, 1) 移动到链表头部。接着，我们插入键值对 (3, 3)，由于缓存已满，最久未被访问的节点 (2, 2) 将被淘汰。然后，我们尝试访问键为 2 的值，由于节点 (2, 2) 已被淘汰，所以返回 -1。接着，我们插入键值对 (4, 4)，此时节点 (1, 1) 被淘汰。最后，我们分别访问键为 3 和 4 的值，验证它们是否被正确地存储在缓存中。

五、总结

通过使用 Java 实现 LRU 算法，我们可以有效地管理缓存，提高程序的性能。在实际应用中，LRU 算法可以用于数据库缓存、Web 服务器缓存等场景。希望本文对你理解和实现 LRU 算法有所帮助。