Java 实现 LRU 缓存:一行代码 vs 手写双向链表(附记忆口诀)

Java中实现LRU缓存的最简方案 是直接使用LinkedHashMap,它通过维护插入顺序或访问顺序的链表,天然支持LRU策略。以下是两种实现方式的对比:

方案1:使用LinkedHashMap(最简实现)

java 复制代码
import java.util.LinkedHashMap;
import java.util.Map;

public class LRUCache extends LinkedHashMap<Integer, Integer> {
    private final int capacity;
    
    // 构造函数:设置accessOrder为true,启用访问顺序
    public LRUCache(int capacity) {
        super(capacity, 0.75f, true) {
            @Override
            protected boolean removeEldestEntry(Map.Entry<Integer, Integer> eldest) {
                return size() > capacity; // 超过容量时自动删除最老元素
            }
        };
        this.capacity = capacity;
    }
    
    public int get(int key) {
        return super.getOrDefault(key, -1); // 不存在返回-1
    }
    
    public void put(int key, int value) {
        super.put(key, value);
    }
}

关键点

  1. LinkedHashMap的构造参数:
    • accessOrder=true:按访问顺序排序(最近访问的元素移到尾部)
    • removeEldestEntry():重写此方法,当大小超过容量时自动删除最老元素
  2. 时间复杂度:get/put 均为 O(1)

方案2:手动实现(面试常考)

如果你需要在面试中手动实现(不依赖LinkedHashMap),则需用哈希表+双向链表

java 复制代码
import java.util.HashMap;
import java.util.Map;

// 双向链表节点
class DNode {
    int key, value;
    DNode prev, next;
    public DNode(int k, int v) { key = k; value = v; }
}

public class LRUCache {
    private Map<Integer, DNode> map;
    private DNode head, tail;
    private int capacity;

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

    public int get(int key) {
        if (!map.containsKey(key)) return -1;
        DNode node = map.get(key);
        removeNode(node); // 从链表中删除
        addToHead(node);  // 移到头部(最近使用)
        return node.value;
    }

    public void put(int key, int value) {
        if (map.containsKey(key)) {
            removeNode(map.get(key)); // 已存在则删除
        }
        DNode newNode = new DNode(key, value);
        map.put(key, newNode);
        addToHead(newNode); // 新增到头部
        if (map.size() > capacity) {
            DNode tailNode = removeTail(); // 超容则删除尾部(最久未用)
            map.remove(tailNode.key);
        }
    }

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

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

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

对比选择

方案 优点 适用场景
LinkedHashMap 代码仅需10行,简洁高效 日常开发、快速实现
手动实现 展示底层原理,面试加分项 面试手撕、深入理解LRU机制

记忆口诀(LinkedHashMap版)

java 复制代码
继承LinkedHashMap,仨参数要写对
accessOrder设为true,删除老元素有回调
get/put直接调父类,LRU缓存就这么简单

关键点

  • LinkedHashMap的三个核心参数:初始容量、负载因子、访问顺序
  • 重写removeEldestEntry()方法控制删除策略

这种方案避免了手动维护双向链表的复杂性,适合快速实现功能。但面试中若要求"不使用任何库",则需手动实现版本。

相关推荐
西阳未落13 分钟前
欧拉路径与欧拉回路
算法·深度优先
Swift社区26 分钟前
LeetCode 390 消除游戏
算法·leetcode·游戏
橘颂TA1 小时前
【剑斩OFFER】优雅的解法——三数之和
算法
我爱工作&工作love我1 小时前
2024-CSP-J T3 小木棍
算法·动态规划
DatGuy1 小时前
Week 18: 深度学习补遗:Stacking和量子运算Deutsch算法
人工智能·深度学习·算法
Nie_Xun3 小时前
ROS1 go2 vlp16 局部避障--3 篇
算法
Da Da 泓7 小时前
LinkedList模拟实现
java·开发语言·数据结构·学习·算法
未知陨落7 小时前
LeetCode:68.寻找两个正序数组的中位数
算法·leetcode
努力学习的小廉9 小时前
我爱学算法之—— 模拟(下)
c++·算法
海琴烟Sunshine10 小时前
Leetcode 26. 删除有序数组中的重复项
java·算法·leetcode