Java实现LRU缓存的代码详解

2025-03-05 09:03:05 作者：Katie。

LRU缓存是一种缓存替换策略,当缓存容量达到上限时,LRU 会淘汰掉最近最少使用的缓存项,在 Java 中,我们可以使用 LinkedHashMap 来实现一个简单的 LRU 缓存,所以本文给大家介绍了Java实现LRU缓存的方法,需要的朋友可以参考下

一、LRU 缓存的基本思想

LRU 缓存是一个有限大小的缓存，每当缓存的容量达到上限时，系统会自动删除最近最少使用的缓存项。LRU 缓存常常用于数据存储、图形处理、操作系统等领域。

LRU 缓存的关键点：

使用最近使用的数据：缓存会保存最近访问过的数据。
淘汰最少使用的数据：当缓存空间满时，删除最近最少使用的项。
维护访问顺序：通常通过链表来维护缓存项的访问顺序。

二、LRU 缓存实现的核心步骤

缓存容量限制：缓存大小固定，当容量达到上限时，需要删除最少使用的缓存项。
快速的查找与删除操作：使用 Map 数据结构提供快速的查找和删除功能，同时使用双向链表来维护元素的访问顺序。
操作顺序：每次访问缓存时，将该元素移动到链表的头部，表示它是最近使用的。超出容量时，将链表尾部的元素删除。

三、LRU 缓存的 Java 实现

我们将使用 LinkedHashMap 来实现 LRU 缓存。LinkedHashMap 保持了元素的插入顺序，可以通过设置其 accessOrder 为 true 来确保按访问顺序维护元素。

四、实现代码

import java.util.*;
 
public class LRUCache<K, V> {
    private final int capacity;
    private final Map<K, V> cache;
    
    // 构造函数，初始化容量并创建一个LinkedHashMap
    public LRUCache(int capacity) {
        this.capacity = capacity;
        // LinkedHashMap 允许通过访问顺序来维护插入顺序
        this.cache = new LinkedHashMap<>(capacity, 0.75f, true);
    }
 
    // 获取缓存中的值
    public V get(K key) {
        if (!cache.containsKey(key)) {
            return null;  // 如果缓存中没有该项，返回null
        }
        return cache.get(key);  // 如果缓存中有该项，返回其值，并将其移动到末尾（表示最近使用）
    }
 
    // 将元素添加到缓存中
    public void put(K key, V value) {
        if (cache.size() >= capacity) {
            // 如果缓存已满，移除最少使用的元素（即链表头部的元素）
            Iterator<Map.Entry<K, V>> iterator = cache.entrySet().iterator();
            if (iterator.hasNext()) {
                iterator.next();
                iterator.remove();
            }
        }
        cache.put(key, value);  // 将新的元素放入缓存
    }
 
    // 打印缓存中的内容
    public void printCache() {
        System.out.println(cache);
    }
 
    public static void main(String[] args) {
        LRUCache<Integer, String> lruCache = new LRUCache<>(3);
        
        // 向缓存添加元素
        lruCache.put(1, "A");
        lruCache.put(2, "B");
        lruCache.put(3, "C");
        
        // 打印缓存内容
        lruCache.printCache();  // 输出: {1=A, 2=B, 3=C}
 
        // 访问一些缓存项
        lruCache.get(1);  // 访问了 1
        lruCache.put(4, "D");  // 插入新的元素，容量已满
        
        // 打印缓存内容
        lruCache.printCache();  // 输出: {3=C, 1=A, 4=D}  (2 被移除，最少使用)
        
        // 继续访问一些缓存项
        lruCache.get(3);  // 访问了 3
        lruCache.put(5, "E");  // 插入新的元素
        
        // 打印缓存内容
        lruCache.printCache();  // 输出: {1=A, 3=C, 5=E}  (4 被移除)
    }
}

五、代码解读

LRUCache 类：
- 使用 LinkedHashMap 来保存缓存数据。其构造函数使用 true 作为第三个参数 accessOrder，以确保缓存按访问顺序排列。
- get 方法用于获取缓存中的数据。如果数据存在，它会自动将该数据移动到最近使用的位置（链表的末尾）。
- put 方法用于将数据添加到缓存中。如果缓存已满，则删除最少使用的数据（链表头部元素）。
缓存容量控制：
- 当缓存的元素数量达到指定容量时，put 方法会通过迭代器移除链表头部的元素，保证缓存不会超出最大容量。
printCache 方法：
- 用于打印当前缓存的内容，帮助调试和查看缓存状态。
main 方法：
- 通过示例演示如何使用 LRU 缓存。
- 向缓存添加了多个元素，然后访问了一些元素并查看缓存中剩余的内容。

六、LRU 缓存的工作原理

缓存初始化：当初始化 LRUCache 时，指定缓存的最大容量。
缓存添加：通过 put 方法向缓存添加元素。如果缓存已满，会删除最少使用的元素。
缓存访问：通过 get 方法访问缓存中的元素，访问后元素会被标记为最近使用。
LRU 删除机制：当容量达到上限时，删除链表头部的元素，即最近最少使用的元素。

七、总结

LRU 缓存 是一种常见的缓存替换策略，用于处理有限大小缓存中的数据。它通过追踪元素的使用顺序来确保删除最少使用的元素。
本文介绍了如何使用 LinkedHashMap 在 Java 中实现 LRU 缓存。通过合理利用 LinkedHashMap 的顺序特性，能够在访问缓存时保持元素的顺序，确保我们能够在缓存满时删除最少使用的元素。

这个实现是一个简化版本，适合用于小型缓存场景，若需要更复杂的缓存控制（如并发支持等），可以进一步优化和扩展。

以上就是Java实现LRU缓存的代码详解的详细内容，更多关于Java LRU缓存的资料请关注脚本之家其它相关文章！