LRU (Least Recently Used) 算法的Java实现

实现代码如下:

import java.util.LinkedHashMap;
import java.util.Map;

/**
 * LRU (Least Recently Used) 算法的Java实现
 * @param <K>
 * @param <V>
 * @author 杨尚川
 */
public class LRUCache<K, V> extends LinkedHashMap<K, V> {
    //缓存大小
    private int cacheSize;

    public LRUCache(int cacheSize) {
        //第三个参数true是关键
        super(10, 0.75f, true);
        this.cacheSize = cacheSize;
    }

    /**
     * 缓存是否已满的判断
     * @param eldest
     * @return
     */
    @Override
    protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
        boolean r = size() > cacheSize;
        if(r){
            System.out.println("清除缓存:"+eldest.getKey());
        }
        return r;
    }

    public static void main(String[] args) {
        LRUCache<String, String> cache = new LRUCache<>(5);
        cache.put("1", "1");
        cache.put("2", "2");
        cache.put("3", "3");
        cache.put("4", "4");
        cache.put("5", "5");

        System.out.println("初始:");
        cache.keySet().forEach(k -> System.out.println(k));
        System.out.println("访问2:");
        cache.get("2");
        cache.keySet().forEach(k -> System.out.println(k));
        System.out.println("访问2、3:");
        cache.get("2");
        cache.get("3");
        cache.keySet().forEach(k -> System.out.println(k));
        System.out.println("增加数据6、7:");
        cache.put("6", "6");
        cache.put("7", "7");
        cache.keySet().forEach(k -> System.out.println(k));
    }
}

运行结果如下:

初始:
1
2
3
4
5
访问2:
1
3
4
5
2
访问2、3:
1
4
5
2
3
增加数据6、7:
清除缓存:1
清除缓存:4
5
2
3
6
7
时间: 2024-12-13 11:25:55

LRU (Least Recently Used) 算法的Java实现的相关文章

使用LRU(last recently used)算法淘汰数据实例

某缓存系统采用LRU淘汰算法,假定缓存容量为4,并且初始为空,那么在顺序访问一下数据项的时候:1,5,1,3,5,2,4,1,2出现缓存直接命中的次数是?,最后缓存中即将准备淘汰的数据项是? 答案:3, 5 解答: 1调入内存 1 5调入内存 1 5 1调入内存 5 1(命中 1,更新次序) 3调入内存 5 1 3 5调入内存 1 3 5 (命中5) 2调入内存 1 3 5 2 4调入内存(1最久未使用,淘汰1) 3 5 2 4 1调入内存(3最久未使用,淘汰3) 5 2 4 1 2调入内存 5

最近最久未使用页面淘汰算法———LRU算法(java实现)

LRU算法,即Last Recently Used ---选择最后一次访问时间距离当前时间最长的一页并淘汰之--即淘汰最长时间没有使用的页 按照最多5块的内存分配情况,实现LRU算法代码如下: public class LRU { private int theArray[]; private int back; //定义队尾 private int currentSize; //队列中存放元素个数 private int maxSize=5; //队列中能存放元素的个数 public LRU(

LRU近期最少使用算法

LRU是Least Recently Used 近期最少使用算法,一种页面置换算法,其实现较为简单,Java实现代码如下 1 import java.util.LinkedList; 2 import java.util.List; 3 4 public class LRU { 5 6 private List<Integer> executeSeries = new LinkedList<Integer>(); 7 8 public LRU(Integer[] executeSe

A LRU Cache in 10 Lines of Java

I had a couple of interviews long ago which asked me to implemented a least recently used (LRU) cache. A cache itself can simply be implemented using a hash table, however adding a size limit gives an interesting twist on the question. Let's take a l

LRU(最近最少使用淘汰算法)基本实现

LRU(Least Recently Used) 出发点:在页式存储管理中,如果一页很长时间未被访问,则它在最近一段时间内也不会被访问,即时间局部性,那我们就把它调出(置换出)内存. 为了实现LRU淘汰算法,需要一些特殊的硬件支持. 三种可行方法 计数器法 特殊栈法 寄存器法 下面给出,栈法的实现代码: 原理: 1 #include <iostream> 2 using namespace std; 3 4 void conduct(int Size, int Num, int A[100])

8皇后以及N皇后算法探究,回溯算法的JAVA实现,非递归,循环控制及其优化

上两篇博客 8皇后以及N皇后算法探究,回溯算法的JAVA实现,递归方案 8皇后以及N皇后算法探究,回溯算法的JAVA实现,非递归,数据结构“栈”实现 研究了递归方法实现回溯,解决N皇后问题,下面我们来探讨一下非递归方案 实验结果令人还是有些失望,原来非递归方案的性能并不比递归方案性能高 代码如下: package com.newflypig.eightqueen; import java.util.Date; /** * 使用循环控制来实现回溯,解决N皇后 * @author [email pr

【LeetCode-面试算法经典-Java实现】【107-Binary Tree Level Order Traversal II(二叉树层序遍历II)】

[107-Binary Tree Level Order Traversal II(二叉树层序遍历II)] [LeetCode-面试算法经典-Java实现][全部题目文件夹索引] 原题 Given a binary tree, return the bottom-up level order traversal of its nodes' values. (ie, from left to right, level by level from leaf to root). For example

【LeetCode-面试算法经典-Java实现】【064-Minimum Path Sum(最小路径和)】

[064-Minimum Path Sum(最小路径和)] [LeetCode-面试算法经典-Java实现][全部题目文件夹索引] 原题 Given a m x n grid filled with non-negative numbers, find a path from top left to bottom right which minimizes the sum of all numbers along its path. Note: You can only move either

7种基本排序算法的Java实现

7种基本排序算法的Java实现 转自我的Github 以下为7种基本排序算法的Java实现,以及复杂度和稳定性的相关信息. 以下为代码片段,完整的代码见Sort.java 插入排序 1 /** 2 * 直接插入排序 3 * 不稳定 4 * 时间复杂度:O(n^2) 5 * 最差时间复杂度:O(n^2) 6 * 空间复杂度:O(1) 7 * 使用场景:大部分元素有序 8 * @param elements 9 * @param comparator 10 * @param <T> 11 */ 1