LinkedHashMap的使用以及LRU算法的实现

最新推荐文章于 2023-04-28 16:44:49 发布
最新推荐文章于 2023-04-28 16:44:49 发布
阅读量1.7k 收藏 2
点赞数 2
分类专栏： java 文章标签： LinkedHashMap LRU
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wangkaishou/article/details/90115011
版权

什么是LinkedHashMap

LinkedHashMap是HashMap的子类，能够记住插入数据的顺序，由于HashMap并不能保证插入数据的顺序，如果我们需要记住插入的顺序的就需要使用LinkedHashMap.

LinkedHashMap的顺序

LinkedHashMap提供两种数据排序的方式，一种是按照插入顺序进行排序，一种按照访问顺序进行排序。

在LinkedHashMap中定义了变量final boolean accessOrder;来标记使用哪种访问方式。由于是final类型的变量，所以它只能在构造方法中赋值，然后就不能再改变数据的排序方式。

下面是一个例子来演示这两种排序方式。输入输入{0,0}...{9,9},然后访问数据，查看数据的排序方式。

按照插入顺序排序

  System.out.println("开始插入顺序的测试");
   //accessOrder 为true，按照访问顺序排序，false：按照插入顺序排序
   LinkedHashMap<Integer, Integer> map = new LinkedHashMap<>(0, 0.75f, false);
   for (int i = 0; i < 10; i ++){
       map.put(i, i);
   }

   System.out.println(map.toString());

   System.out.println(map.get(6));

   System.out.println(map.toString());
   System.out.println("结束插入顺序的测试");

输出结果如下：

{0=0, 1=1, 2=2, 3=3, 4=4, 5=5, 6=6, 7=7, 8=8, 9=9}
6
{0=0, 1=1, 2=2, 3=3, 4=4, 5=5, 6=6, 7=7, 8=8, 9=9}

按照访问顺序排序

  System.out.println("开始访问顺序的测试");
   //accessOrder 为true，按照访问顺序排序，false：按照插入顺序排序
   LinkedHashMap<Integer, Integer> map = new LinkedHashMap<>(0, 0.75f, true);
   for (int i = 0; i < 10; i ++){
       map.put(i, i);
   }

   System.out.println(map.toString());

   System.out.println(map.get(6));

   System.out.println(map.toString());
   System.out.println("结束访问顺序的测试");

输出结果如下:

开始访问顺序的测试
{0=0, 1=1, 2=2, 3=3, 4=4, 5=5, 6=6, 7=7, 8=8, 9=9}
6
{0=0, 1=1, 2=2, 3=3, 4=4, 5=5, 7=7, 8=8, 9=9, 6=6}
结束访问顺序的测试

什么是LRU算法

LRU是Lease Recently User的缩写，意思是最近 最少使用。比如设计一个文件缓存系统，每个文件有自己的大小和访问时间，文件缓存系统有总的大小，当往这个文件系统中放入新的文件时，如果发现超出文件缓存系统的容量，那么把访问时间最旧的文件删掉。所有定义这样一个文件系统的需要记录文件的访问顺序，而通过上面的例子我们知道LinkedHashMap可以轻松实现这个功能。

实现一个最简单的LRU算法

这个算法实现最多存放maxSize个数据，当存放数据的个数超出maxSize时，删除最近最少使用的数据。

//map的最大容量是10
final int maxSize = 10;
Map<Integer, Integer> map = new LinkedHashMap<Integer, Integer>(0, 0.75f, true) {
  @Override
  protected boolean removeEldestEntry(Map.Entry<Integer, Integer> eldest) {
      return size() > maxSize;
  }
};

System.out.println(map.size());
for (int i = 0; i < 10; i ++){
  map.put(i, i);
}
System.out.println("当前有10个数据："+map.toString());
System.out.println(map.get(6));
System.out.println("访问key为6的数据后："+map.toString());
map.put(11,11);
System.out.println("插入第11个数据后："+map.toString());

输出结果如下：

当前有10个数据：{0=0, 1=1, 2=2, 3=3, 4=4, 5=5, 6=6, 7=7, 8=8, 9=9}
6
访问key为6的数据后：{0=0, 1=1, 2=2, 3=3, 4=4, 5=5, 7=7, 8=8, 9=9, 6=6}
插入第11个数据后：{1=1, 2=2, 3=3, 4=4, 5=5, 7=7, 8=8, 9=9, 6=6, 11=11}

实现一个通用的LRU缓存算法。

上面的实现的LRU算法中默认的每个数据的大小是为1，如果是文件存储系统，每个文件大小是不一样的，所以一个通用的LRU缓存算法还有提供一个计算数据方法的大小，下面一个最小化的
通用LRU缓存算法实现，该算法参照了Android中LruCache类的实现。

public class LruCache<K,V> {
    private LinkedHashMap<K,V> map;
    //最大缓存容量
    private int maxSize;
    //当前容量
    private int size;


    public LruCache(int maxSize){
        this.maxSize = maxSize;
        map = new LinkedHashMap<>(0, 0.75f, true);
    }

    /**
     * 插入一条数据，更新当前容量大小，并检测是否已超出容量
     * @param key
     * @param value
     */
    public void put(K key, V value){
        size += sizeOf(key, value);
        map.put(key, value);
        trimSize(maxSize);
    }

    /**
     * 获取一条数据
     * @param key
     * @return
     */
    public V get(K key){
        V v;
        synchronized (this){
            v = map.get(key);
        }
        return v;
    }

    /**
     * 删除一条数据，并更新当前容量
     * @param key
     * @return
     */
    public V remote(K key){
        V v = map.remove(key);
        size -= sizeOf(key, v);
        return v;
    }

    /**
     * 检测当前容量是否已经超过最大容量，如果超过就开始清除数据，知道size小于maxSize为止。
     * @param maxSize
     */
    public void trimSize(int maxSize){
        while (true) {
            K key;
            V value;
            synchronized (this) {
                if (size < 0 || (map.isEmpty() && size != 0)) {
                    throw new IllegalStateException(getClass().getName()
                            + ".sizeOf() is reporting inconsistent results!");
                }

                if (size <= maxSize || map.isEmpty()) {
                    break;
                }

                Map.Entry<K, V> toEvict = map.entrySet().iterator().next();
                key = toEvict.getKey();
                value = toEvict.getValue();
                map.remove(key);
                size -= sizeOf(key, value);
            }
        }
    }

    /**
     * 重新调整缓存总大小
     * @param maxSize
     */
    public void resize(int maxSize){
        if (maxSize <= 0){
            throw new IllegalArgumentException("MaxSize 不能小于等于0！");
        }
        synchronized (this){
            this.maxSize = maxSize;
        }
        resize(maxSize);
    }

    /**
     * 数据大小.默认为1，想要修改数据大小，还需要子类实现
     * @param key
     * @param value
     * @return
     */
    protected int sizeOf(K key, V value) {
        return 1;
    }

    /**
     * 清除
     * @return
     */
    public void clear(){
        synchronized (this){
            map.clear();
        }
    }

    @Override
    public String toString() {
        return "size:"+size+";maxSize:"+maxSize+" "+map.toString();
    }
}

使用LruCache.

  • 定义最大容量为10，每个数据的大小为1
 final int maxSize = 10;
LruCache<Integer,Integer> lruCache = new LruCache<Integer, Integer>(maxSize){
  @Override
  protected int sizeOf(Integer key, Integer value) {
      return 1;//数据大小为1
  }
};

for (int i = 0; i < maxSize; i ++){
  lruCache.put(i, i);
}
System.out.println("当前数据："+lruCache.toString());
System.out.println("key为6的数据"+lruCache.get(6));
System.out.println("访问key为6的数据后："+lruCache.toString());
lruCache.put(11,11);
System.out.println("插入value为11的数据后："+lruCache.toString());

输出结果为：

当前数据：size:10;maxSize:10 {0=0, 1=1, 2=2, 3=3, 4=4, 5=5, 6=6, 7=7, 8=8, 9=9}
key为6的数据6
访问key为6的数据后：size:10;maxSize:10 {0=0, 1=1, 2=2, 3=3, 4=4, 5=5, 7=7, 8=8, 9=9, 6=6}
插入value为11的数据后：size:10;maxSize:10 {1=1, 2=2, 3=3, 4=4, 5=5, 7=7, 8=8, 9=9, 6=6, 11=11}
  • 定义最大容量为10，每个数据的大小为2
 final int maxSize = 10;
LruCache<Integer,Integer> lruCache = new LruCache<Integer, Integer>(maxSize){
  @Override
  protected int sizeOf(Integer key, Integer value) {
      return 1;//数据大小为2
  }
};

for (int i = 0; i < maxSize; i ++){
  lruCache.put(i, i);
}
System.out.println("当前数据："+lruCache.toString());
System.out.println("key为6的数据"+lruCache.get(6));
System.out.println("访问key为6的数据后："+lruCache.toString());
lruCache.put(11,11);
System.out.println("插入value为11的数据后："+lruCache.toString());

输出结果为：

当前数据：size:10;maxSize:10 {5=5, 6=6, 7=7, 8=8, 9=9}
key为6的数据6
访问key为6的数据后：size:10;maxSize:10 {5=5, 7=7, 8=8, 9=9, 6=6}
插入value为11的数据后：size:10;maxSize:10 {7=7, 8=8, 9=9, 6=6, 11=11}
  • 定义最大容量为10，每个数据的大小为value
final int maxSize = 10;
LruCache<Integer,Integer> lruCache = new LruCache<Integer, Integer>(maxSize){
  @Override
  protected int sizeOf(Integer key, Integer value) {
      return value;//数据大小为value
  }
};

for (int i = 0; i < maxSize; i ++){
  lruCache.put(i, i);
}
System.out.println("当前数据："+lruCache.toString());
System.out.println("key为6的数据"+lruCache.get(6));
System.out.println("访问key为6的数据后："+lruCache.toString());
lruCache.put(11,11);
System.out.println("插入value为11的数据后："+lruCache.toString());

输出结果为：

当前数据：size:9;maxSize:10 {9=9}
key为6的数据null
访问key为6的数据后：size:9;maxSize:10 {9=9}
插入value为11的数据后：size:0;maxSize:10 {}
yumodev
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
leetcode下载-LruCache:实现LRU算法的Cache类
06-29
leetcode下载 LruCache LruCache是基于Android SDK中的LruCache类参考实现的LRU算法缓存存储类. 原理 之前分析过Lru算法的实现方式:HashMap+双向链表,参考链接: 这里主要介绍Android SDK中LruCache缓存算法的实现. 构造函数 LruCache只有一个构造函数,并且有一个必传参数: public LruCache(int maxSize) { if (maxSize <= 0) { throw new IllegalArgumentException("maxSize <= 0"); } // 初始化最大缓存大小. this.maxSize = maxSize; // 初始化LinkedHashMap.其中: // 1. initialCapacity, 初始大小. // 2. loadFactor, 负载因子. // 3. accessOrder, true:基于访问顺序排序, false:基于插入顺序排序. this.map = new LinkedHashMap<K>(0, 0.75f, true); }
LinkedHashMap
sinat_34814635的博客
01-30 374
一、基础概念 下图很好地还原了LinkedHashMap的原貌：HashMap和双向链表的密切配合和分工合作造就了LinkedHashMap。特别需要注意的是，next用于维护HashMap各个桶中的Entry链，before、after用于维护LinkedHashMap的双向链表，虽然它们的作用对象都是Entry，但是各自分离，是两码事儿。 LinkedHashMap的继承结构如图： HashMap与LinkedHashMap的Entry结构示意图如下图所示 1.遍历 LinkedHashMap进行
LinkedHashMap源码及LRU实现原理
starsray的博客
08-30 945
基本认识 LinkedHashMap位于java.util包，于JDK1.4引入，属于Java Collections Framework的成员。查看其UML关系如下图所示： HashMap在很多场景下都满足K-V的存取，而且在非多线程的场景下也能保持不错的性能，但是HashMap有一个缺点就是不能保证元素的顺序，相比之下，LinkedHashMap就满足了这点，可以保证元素的插入顺序。 Lin...
LinkedHashMap实现LRU
张井天的博客
05-12 2205
前言： LinkedHashMap是HashMap的子类,在原有HashMap数据结构的基础上,它还维护着一个双向链表链接所有entry,这个链表定义了迭代顺序，通常是数据插入的顺序。 上图我只画了链表，其实红黑树节点也是一样的，只是节点类型不一样而已 也就是说我们遍历LinkedHashMap的时候,是从head指针指向的节点开始遍历,一直到tail指向的节点。 源码 public class LinkedHashMap<K,V> extends HashMap<K,V> imp
Java集合类（六）——LinkedHashMap、LRU
wanger61的博客
09-24 243
LinkedHashMap、LRU 概述 LinkedHashMap继承于HashMap，在HashMap的基础上，新增了两个特性： 支持以节点的插入顺序来迭代该map内的所有节点； 支持缓存设计中LRU的特性，即LinkedHashMap支持按访问顺序来排序节点，具体在内部实现为如果开启了这个特性，则每次通过get方法访问了一个节点，则该节点会被移动到内部的双向链表的末尾，故双向链表的头...
LRU算法四种实现方式介绍:使用LinkedHashMap实现
apache的专栏
07-09 464
LRU算法四种实现方式介绍:使用LinkedHashMap实现 https://blog.csdn.net/elricboa/article/details/78847305
实现 LRU 算法，和 Caffeine 和 Redis 中的缓存淘汰策略.docx
07-10
通过一个特殊的构造函数，三个参数的这种，最后一个布尔值参数表示是否要维护最近访问顺序，如果是 true 的话会维护最近访问的顺序，如果是 false 的话，只会维护插入...LinkedHashMap这种结构非常适合构造 LRU 缓存。
Java和Android的LRU缓存及实现原理
01-20
Android提供了LRUCache类，可以方便的使用它来实现LRU算法的缓存。Java提供了LinkedHashMap，可以用该类很方便的实现LRU算法，Java的LRULinkedHashMap就是直接继承了LinkedHashMap，进行了极少的改动后就可以实现LRU...
Java和Android的Lru缓存及其实现原理
01-20
　Android提供了LRUCache类，可以方便的使用它来实现LRU算法的缓存。Java提供了LinkedHashMap，可以用该类很方便的实现LRU算法，Java的LRULinkedHashMap是直接继承了LinkedHashMap，进行了极少的改动后可以实现LRU...
leetcodelrucache-algorithm:算法学习和练习
06-30
基于JavaLinkedHashMap实现的 LRU 算法 algorithm.consistentHashing ConsistentHash： 一致性Hash算法 algorithm.cap algorithm.subset 给一个set打印出所有子集 jdk jdk 知识 jdk.autoboxing 自动装箱拆箱 jdk....
LRU使用LinkedHashMap实现（主要分析LinkedHashMap的原理）
qq_38732834的博客
06-17 454
LC上有这么一道题让实现一个LRU，LRU如上描述就是一个有容量限制当容量满时会自动移除最后一次时间时间最晚的缓存结构。 想到Redis中的ZSET结构(主要是想到了昨天学的漏斗限流…)，不过只能存储key不能存储value… 在Java中也有排序表的结构，可以使用一个TreeMap，key为一个HashMap，HashMap存储题目中的key和value，TreeMap的value为操作时间戳，每访问一次或者修改一次就更新。如果超出容量设定了就移除时间戳最靠前的那一个。 不过Java中有种更合适于干这事.
LinkedHashMap顺序迭代原理与LRU算法实现
m0_56602092的博客
04-28 1205
LinkedHashMap可保证通过keySet()、entrySet()、forEach()等方法获取的元素具有顺序性，顺序分为两种： - 添加顺序：获取元素的顺序与其被添加的顺序一致。 - 访问顺序：按元素被访问的时间进行排序，越近被访问的排在越后面，put和get等方法都表示访问。 在LinkedHashMap通过成员变量accessOrder来决定按哪种顺序排序，默认为false添加顺序，只有通过下面这个构造方法在创建LinkedHashMap时将accessOrder设置为true，才表示访问顺
使用LinkedHashMap实现LRU算法
张维鹏的博客
01-31 6641
LRU算法，最近最少使用原则，如果要实现该算法，可以借助LinkedHashMap数据结构，LinkedHashMap继承HashMap，底层使用哈希表和双向链表来保存所有元素，使用LinkedHashMap可以确保元素按照顺序进行存储。 默认情况下，LinkedHashMap是按照元素的添加顺序存储，也可以启用按照访问顺序存储，即最近读取的数据放在最前面，最早读取的数据放在最后面，然后它还有一个判断是否删除最老数据的方法，默认是返回false，即不删除数据。 下面就基于这两种存储方式，简单展示一下如何
链表的应用（LRU缓存淘汰算法）
qq_43536300的博客
02-29 252
缓存：是一种提高数据读取性能的技术，在硬件设计、软件开发中都有着非常广泛的应用，比如常见的 CPU 缓存、数据库缓存、浏览器缓存等等。 LRU：缓存的大小有限，当缓存被用满时数据有的需要删除，有的需要保留，这里我们采用的策略是LRU（最近最少使用）缓存淘汰算法。 LRU缓存淘汰算法：我们维护一个有序单链表，越靠近链表尾部的结点是越早之前访问的。当有一个新的数据被访问时，我们从链表头开始顺序遍历...
LinkedHashMap原理及LRU应用
pjblogs的专栏
05-06 419
LinkedHashMap概述 本文基于JDK8，之前版本可能不一样。 LinkedHashMap是HashMap的一个子类，它保留插入的顺序，如果需要输出的顺序和输入时的相同，那么就选用LinkedHashMap。 LinkedHashMap实现与HashMap的不同之处在于，后者维护着一个运行于所有条目的双重链接列表。此链接列表定义了迭代顺序，该迭代顺序可以是插入顺序或者是访问顺序。 根
LRU缓存机制（LInkedHashMap实现）
weixin_43857345的博客
12-08 375
题目 运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制 。 实现 LRUCache 类： LRUCache(int capacity) ：以正整数作为容量 capacity 初始化 LRU 缓存 int get(int key) ：如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。 void put(int key, int value) ：如果关键字已经存在，则变更其数据值；如果关键字不存在，则插入该组「关键字-值」。当缓存容量达到上限时，它应该在写入新数
LinkedHashMap实现LRU算法
Knight
02-18 999
LinkedHashMap实现LRU算法
如何使用 LinkedHashMap 实现 LRU 缓存？
java_beautiful的博客
11-14 566
缓存是提高数据读取性能的通用技术，在硬件和软件设计中被广泛使用，例如CPU 缓存、Glide 内存缓存，数据库缓存等。由于缓存空间不可能无限大，当缓存容量占满时，就需要利用某种策略将部分数据换出缓存，这就是缓存的替换策略 / 淘汰问题。使用一个随机数生成器随机地选择要被淘汰的数据块；记录各个数据块的访问时间，最早访问的数据最先被淘汰；记录各个数据块的访问“时间戳”，最近最久未使用的数据最先被淘汰。
LRU的LinkedHashMap以及链表和Hashmap的实现（Java）
weixin_43979716的博客
07-30 257
LRU缓存实现双向链表+HashMap利用LinkedHashMap实现的LRULinkedHashMap的类注释翻译LinkedHashMap类介绍我所翻译的英文原文。 双向链表+HashMap 大体思路就是用双向链表实现最老的在队首，最新的在队尾。 同时用HashMap进行查找，解决链表查找慢的问题 import java.util.HashMap; import java.util.Objects; /** * 类 K 需要重写equals和hashCode方法 * @author : rhyth
基于LinkedHashMap实现LRU算法
最新发布
09-27
基于LinkedHashMap实现LRU算法的核心是继承LinkedHashMap类，并设置accessOrder参数为true，这样可以按照访问顺序对元素进行排序。同时，需要重写removeEldestEntry()方法来控制缓存的大小，当缓存满时删除最老的元素。 以下是基于LinkedHashMap实现LRU算法的代码示例： ```java import java.util.LinkedHashMap; import java.util.Map; public class LRUCache<K, V> extends LinkedHashMap<K, V> { private int capacity; public LRUCache(int capacity) { super(16, 0.75f, true); this.capacity = capacity; } @Override protected boolean removeEldestEntry(Map.Entry<K, V> eldest) { return size() > capacity; } } // 使用示例 public static void main(String[] args) { LRUCache<String, Integer> cache = new LRUCache<>(3); cache.put("1", 1); cache.put("2", 2); cache.put("3", 3); System.out.println(cache.get("1")); // 输出1 cache.put("4", 4); System.out.println(cache.get("2")); // 输出null cache.put("5", 5); System.out.println(cache.containsKey("3")); // 输出false cache.put("6", 6); // 输出缓存中的键值对 cache.forEach((k, v) -> System.out.println(k + ":" + v)); // 输出6:6 4:4 5:5 System.out.println(cache.size()); // 输出3 } ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值