LruCache实现

LRU最近最少使用算法

一、LRU算法

1.简介

LRU(Least Recently Used,最近最少使用)算法是一种常用的缓存淘汰策略,当缓存达到其容量上限时,它会移除那些最久没有被访问的数据项。这种策略基于这样一个假设:如果一个数据项在近期没有被访问过,那么在未来一段时间内也不太可能被访问。

2.LRU算法的核心思想

LRU算法的核心在于追踪每个数据项的访问历史,并优先保留最近被访问过的数据项。具体来说,每当有新的数据需要存储而缓存已满时,LRU算法会选择移除那个最长时间未被访问的数据项。

二、算法题目

1.LeetCode题目

146. LRU 缓存

2.实现

java 复制代码
class LRUCache extends LinkedHashMap<Integer, Integer> {

        private int capacity;

        public LRUCache(int capacity) {
            super(capacity, 0.75F, true);
            this.capacity = capacity;
        }

        public int get(int key) {
            return getOrDefault(key, -1);
        }

        public void put(int key, int value) {
            super.put(key, value);
        }

        @Override
        protected boolean removeEldestEntry(Map.Entry<Integer, Integer> eldest) {
            return size() > capacity;
        }
    }

/**
 * Your LRUCache object will be instantiated and called as such:
 * LRUCache obj = new LRUCache(capacity);
 * int param_1 = obj.get(key);
 * obj.put(key,value);
 */

三、项目中实现

  • 定义Cache接口
java 复制代码
package com.zzc.design.cache;

import java.util.concurrent.Callable;

public interface Cache<K, V> {

    /**
     * 添加值到缓存中,如果key已经存在,值将会被覆盖
     * @param key
     * @param val
     */
    void put(K key, V val);

    /**
     * 根据key从缓存中获取value
     * @param key
     * @return
     */
    V get(K key);

    /**
     * "加载-通过"模式(load-through pattern)
     * 从缓存中获取值,如果该值不存在,则通过给定的函数处理并将其结果更新到缓存中。
     * @param key
     * @param call
     * @return
     * @throws Exception
     */
    V get(K key, Callable<? extends V> call) throws Exception;

    /**
     * 通过key移除缓存
     * @param key
     * @return
     */
    V remove(K key);

    /**
     * 清除整个缓存
     */
    void clear();

    /**
     * 缓存数量大小
     * @return
     */
    int getCapacity();

}
  • 实现具体存储key-value数据的接口
java 复制代码
package com.zzc.design.cache;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.Callable;

public class SimpleCache<K, V> implements Cache<K, V> {

    private final Map<K, V> cache;

    public SimpleCache(int size) {
        cache = new HashMap<>(size);
    }

    @Override
    public void put(K key, V val) {
        cache.put(key, val);
    }

    @Override
    public V get(K key) {
        return cache.get(key);
    }

    @Override
    public V get(K key, Callable<? extends V> call) throws Exception {
        if (cache.containsKey(key)) {
            return cache.get(key);
        } else {
            V v2 = call.call();
            cache.put(key, v2);
            return v2;
        }
    }

    @Override
    public V remove(K key) {
        return cache.remove(key);
    }

    @Override
    public void clear() {
        cache.clear();
    }

    @Override
    public int getCapacity() {
        return cache.size();
    }

}
  • 拓展LRU缓存类型
java 复制代码
package com.zzc.design.cache.lru;

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.concurrent.Callable;

public class LruCache<K, V> implements Cache<K, V> {

    /**
     * 存储键值对数据
     */
    private final Cache<K, V> delegate;

    /**
     * 跟踪键的访问顺序,从而实现 LRU 策略
     */
    private Map<K, V> visits;

    /**
     * 记录最近要被移除的最老键
     */
    private K eldestKey;

    public LruCache(Cache<K, V> delegate, int capacity) {
        this.delegate = delegate;
        setCapacity(capacity);
    }

    public void setCapacity(final int capacity) {
        visits = new LinkedHashMap<K, V>(capacity, .75F, true) {

            @Override
            protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
                boolean tooBig = size() > capacity;
                if (tooBig) {
                    eldestKey = eldest.getKey();
                }
                return tooBig;
            }
        };
    }

    @Override
    public void put(K key, V val) {
        delegate.put(key, val);
        cycleKeyList(key);
    }

    @Override
    public V get(K key) {
        visits.get(key);
        return delegate.get(key);
    }

    @Override
    public V get(K key, Callable<? extends V> call) throws Exception {
        return delegate.get(key, call);
    }

    @Override
    public V remove(K key) {
        return delegate.remove(key);
    }

    @Override
    public void clear() {
        delegate.clear();
        visits.clear();
    }

    @Override
    public int getCapacity() {
        return delegate.getCapacity();
    }

    private void cycleKeyList(K key) {
        visits.put(key, null);
        if (eldestKey != null) {
            delegate.remove(eldestKey);
            eldestKey = null;
        }
    }
}
  • Demo示例
java 复制代码
package com.zzc.design.cache.lru;

import com.zzc.design.cache.Cache;
import com.zzc.design.cache.SimpleCache;

public class Demo {

    private static final int initCapacity = 1;
    private static final int maxCapacity = 3;

    public static void main(String[] args) {
        Cache<String, String> cache = new LruCache<>(new SimpleCache<>(initCapacity), maxCapacity);
        cache.put("key1", "value1");
        cache.put("key2", "value2");
        cache.put("key3", "value3");
        System.out.println(cache.get("key1"));//访问key1
        System.out.println(cache.get("key2"));//访问key2
        System.out.println(cache.get("key3"));//访问key3
        System.out.println(cache.get("key1"));//访问key1
        System.out.println(cache.get("key2"));//访问key2
        cache.put("key4", "value4");//新增key4
        System.out.println(cache.get("key3"));//key3的访问次数最少,在添加key4的时候被删除掉了
    }

}
/*
 * 结果:
 * value1
 * value2
 * value3
 * value1
 * value2
 * null
 */
相关推荐
果果软件4 小时前
2026 后台管理系统选型:若依、JeecgBoot、芋道、NocoBase 和 GewuMind Boot 怎么选?
java·人工智能·后端·ai·开源
码云社区7 小时前
Java家政服务系统源码:人员技能、服务范围与多商家业务落地
java·开发语言·家政服务·家政小程序·家政系统
摇滚侠8 小时前
《On Java 中文版 基础卷》阅读笔记 接口 18
java·笔记·python
CoderYanger9 小时前
Java EE 进阶:9.MyBatis 操作数据库(进阶)(第八弹):MyBatis Generator
java·数据库·spring boot·spring·java-ee·tomcat·mybatis
jaysee-sjc11 小时前
【黑马点评】Day02:优惠券秒杀与分布式锁
java·分布式·nginx·spring·node.js·tomcat·maven
秋天的怀念_David12 小时前
算法一千零一夜 · 第三十五夜 · 恢复风暴
java·程序人生·算法
考虑考虑12 小时前
JDK27中的加密对象的 PEM 编码
java·后端·java ee
行者-全栈开发13 小时前
SpringBoot + GraalVM 原生编译实战:启动时间从8秒到0.5秒的极致优化
java·spring boot·后端
CoderYanger13 小时前
Java EE 进阶:10. MyBatis-Plus使用(第一弹)
java·spring boot·后端·sql·spring·java-ee·mybatis
大胖爱学习_MJ15 小时前
超越向量检索:用 Spring Boot + Neo4j 手搓 GraphRAG 知识图谱记忆
java·后端·python