最近最少使用LRU（Least Recently Used）算法java实现

2401_83412172

于 2024-04-22 04:45:15 发布

阅读量723

点赞数 12

分类专栏：程序员文章标签：算法 java 开发语言

本文链接：https://blog.csdn.net/2401_83412172/article/details/138055038

版权

程序员专栏收录该内容

686 篇文章 0 订阅

订阅专栏

本文详细介绍了LRU算法的实现，使用HashMap和双向链表构建了一个简单的LRU缓存，展示了put和get操作如何维护缓存的最新使用顺序以及在缓存满时的淘汰策略。

摘要由CSDN通过智能技术生成

public LRUCache(int cacheSize) {

super(cacheSize, 0.75f, true);

this.cacheSize = cacheSize;

}

@Override

protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {

return size() > cacheSize;

}

public static void main(String[] args) {

LRUCache lru = new LRUCache(3);

lru.put(“1”, 1);

lru.put(“2”, 2);

lru.put(“3”, 3);

lru.put(“4”, 4);

lru.printLRU(lru);

System.out.println();

lru.get(“3”);

lru.printLRU(lru);

}

public void printLRU(LRUCache lru) {

Iterator<Map.Entry<String, Integer>> iterator = lru.entrySet().iterator();

while (iterator.hasNext()) {

Map.Entry<String, Integer> entry = iterator.next();

System.out.println("key = " + entry.getKey() + ", value = " + entry.getValue());

}

输出如下：

key = 2, value = 2

key = 3, value = 3

key = 4, value = 4

key = 2, value = 2

key = 4, value = 4

key = 3, value = 3

可以看到，执行了 lru.put(“4”, 4) 之后，key = 1 就被remove了；当执行 lru.get(“3”) 之后，key = 3被挪到了双向链表的最前面。

二.手撸 LRU 算法实现（Hash表 + 双向链表）

上面的 LRU 算法实现，有点取巧，通常在面试的时候，面试官希望看到具体的算法实现逻辑，而不是使用 LinkedHashMap 已有的功能。当然了，在工作当中，还是不要自己来实现了。

package algorithm.lru;

import java.util.concurrent.ConcurrentHashMap;

/**

* LRU (Least recently used) 最近最少使用

* @date: 2021/12/12 22:19

public class LruCache {

private static ConcurrentHashMap<String, Node> cacheMap;

private static volatile int count;

private static int capacity;

private Node head = new Node();

private Node tail = new Node();

LruCache(int capacity) {

this.count = 0;

this.capacity = capacity;

cacheMap = new ConcurrentHashMap<>();

this.tail.pre = head;

this.head.next = tail;

}

private static class Node {

Node() {

}

Node(String key) {

this.key = key;

this.value = Integer.parseInt(key);

}

private String key;

private int value;

private Node pre;

private Node next;

public String getKey() {

return this.key;

}

public void put(Node node) {

Node existNode = get(node);

if (existNode != null) {

// cacheMap中node存在,先remove节点,再把节点移到链表头部

removeNode(existNode);

// 在链表头部插入node

headAdd(existNode);

} else {

// cacheMap中node不存在,则插入node

if (count == capacity) {

// 缓存已满,在链表尾部remove

tailRemove();

count–;

}

headAdd(node);

count++;

cacheMap.put(node.getKey(), node);

}

public void headAdd(Node node) {

node.next = head.next;

head.next.pre = node;

node.pre = head;

head.next = node;

}

public void removeNode(Node node) {

node.pre.next = node.next;

node.next.pre = node.pre;

}

public void tailRemove() {

tail.pre.pre.next = tail;

tail.pre = tail.pre.pre;

}

public Node get(Node node) {

return cacheMap.get(node.getKey());

}

public void print() {

Node node = head;

System.out.println(“========================================”);

while (node.next != null && node.next != tail) {

System.out.println(node.next.key + " count = " + count);

node = node.next;

}

public static void main(String[] args) {

Node node1 = new Node(“1”);

Node node2 = new Node(“2”);

Node node3 = new Node(“3”);

Node node4 = new Node(“4”);

LruCache lruCache1 = new LruCache(3);

lruCache1.put(node1);

lruCache1.print();

lruCache1.put(node2);

lruCache1.print();

lruCache1.put(node3);

lruCache1.print();

lruCache1.put(node4);

lruCache1.print();

System.out.println(“”);

System.out.println(“###################################################”);

System.out.println(“”);

Node node5 = new Node(“5”);

Node node6 = new Node(“6”);

Node node7 = new Node(“7”);

LruCache lruCache3 = new LruCache(3);

lruCache3.put(node5);

lruCache3.print();

lruCache3.put(node6);

lruCache3.print();

lruCache3.put(node7);

lruCache3.print();

lruCache3.put(node5);

lruCache3.print();

System.out.println(“”);

System.out.println(“###################################################”);

System.out.println(“”);

Node node8 = new Node(“8”);

LruCache lruCache2 = new LruCache(3);

lruCache2.put(node8);

lruCache2.print();

lruCache2.put(node8);

lruCache2.print();

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

结尾

查漏补缺：Java岗千+道面试题Java基础+全家桶+容器+反射+异常等

这不止是一份面试清单，更是一种”被期望的责任“，因为有无数个待面试者，希望从这篇文章中，找出通往期望公司的”钥匙“，所以上面每道选题都是结合我自身的经验于千万个面试题中经过艰辛的两周，一个题一个题筛选出来再次对好答案和格式做出来的，面试的答案也是再三斟酌，深怕误人子弟是小，影响他人仕途才是大过，也希望您能把这篇文章分享给更多的朋友，让他帮助更多的人，帮助他人，快乐自己，最后，感谢您的阅读。

由于细节内容实在太多啦，在这里我花了两周的时间把这些答案整理成一份文档了，在这里只把部分知识点截图出来粗略的介绍，每个小节点里面都有更细化的内容！
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
tyle=“zoom: 33%;” />