LinkedHashMap 实现

最新推荐文章于 2024-09-10 20:55:53 发布
最新推荐文章于 2024-09-10 20:55:53 发布
阅读量1.4k 收藏 1
点赞数 1
原文链接：https://www.cnblogs.com/chenssy/p/15164873.html
版权

利用 LinkedHashMap 的原因就在于 LinkedHashMap 是有序的，默认情况下是按照元素的添加顺序存储的，也可以调整为根据访问顺序来调整内部顺序（设置参数 accessOrder 进行调整），即最近读取的数据放在最前面，我们就是利用 LinkedHashMap 的这个特性来实现 LRU。先来一个简单的例子吧：

public static void main(String[] args){
    Map<String,String> map = new LinkedHashMap(10,0.75f,true);

    map.put("1","a");
    map.put("2","b");
    map.put("3","c");
    map.put("4","d");

    System.out.println("原始顺序为：");
    for(Iterator<Map.Entry<String,String>> it = map.entrySet().iterator();it.hasNext();){
        System.out.print(it.next().getKey() + "    ");
    }
    System.out.println();

    map.get("2");

    System.out.println("访问 4 之后的顺序为：");
    for(Iterator<Map.Entry<String,String>> it = map.entrySet().iterator();it.hasNext();){
        System.out.print(it.next().getKey() + "    ");
    }
}

运行结果：

原始顺序为：
1 2 3 4
访问 4 之后的顺序为：
1 3 4 2
更多关于 LinkedHashMap，请看这篇文章：图解集合6：LinkedHashMap

LinkedHashMap 实现 LRU 有两种方式，一种是继承 LinkedHashMap，一种是利用组合的方式，下面分别演示这两种情况。

继承 LinkedHashMap
采用继承的方式实现起来是非常简单的，因为 LinkedHashMap 本身就已经具备了 LRU 的特性，我们只需要实现一点：当容器中元素个数超过我们设定的容量后，删除第一个元素即可。同时由于 LinkedHashMap 本身不具备线程安全，我们需要确保他线程安全，这个也很简单，重写 LinkedHashMap 的 get() 和 put() 方法即可，或者使用 Collections.synchronizedMap() 方法也可以。实现如下：

public class LRUCacheLinkedHashMap<K,V> extends LinkedHashMap<K,V> {

/**
 * 定一缓存容量
 */
private int capacity;

LRUCacheLinkedHashMap(int capacity){
    // AccessOrder = true
    super(capacity,0.75f,true);

    this.capacity = capacity;
}

/**
 * 实现LRU的关键方法，如果 map 里面的元素个数大于了缓存最大容量，则删除链表的顶端元素
 *
 * @param eldest
 * @return
 */
@Override
public boolean removeEldestEntry(Map.Entry<K, V> eldest){
    System.out.println(eldest.getKey() + "=" + eldest.getValue());
    return size()>capacity;
}

@Override
public synchronized V get(Object key) {
    return super.get(key);
}

@Override
public synchronized V put(K key, V value) {
    return super.put(key, value);
}

}
验证

public static void main(String[] args){
LRUCacheLinkedHashMap cache = new LRUCacheLinkedHashMap(5);

    cache.put("1","a");
    cache.put("2","b");
    cache.put("3","c");
    cache.put("4","d");
    cache.put("5","e");

    System.out.println("插入 5 个元素后的顺序");
    printlnCache(cache);

    // 插入第 6 个元素
    cache.put("6","e");

    System.out.println("插入第 6 个元素后的顺序");
    printlnCache(cache);

    // 访问 第 3 个元素
    cache.get("3");

    System.out.println("访问元素 3 后的顺序");
    printlnCache(cache);

}

private static void printlnCache(LRUCacheLinkedHashMap cacheMap){
    for(Iterator<Map.Entry<String,String>> it = cacheMap.entrySet().iterator(); it.hasNext();){
        System.out.print(it.next().getKey() + "    ");
    }
    System.out.println();
}

运行结果：

插入 5 个元素后的顺序
1 2 3 4 5
插入第 6 个元素后的顺序
2 3 4 5 6
访问元素 3 后的顺序
2 4 5 6 3
运行结果完全符合我们的预期

组合 LinkedHashMap
使用组合的方式可能会更加优雅些，但是由于没有实现 Map 接口，所以就不能使用 Collections.synchronizedMap() 方式来保证线程安全性了，所以需要在每个方法处增加 synchronized 来确保线程安全。实现方式如下：

public class LRUCache<K,V> {
private int capacity;

private Map<K,V> cacheMap;

public LRUCache(int capacity){
    this.capacity = capacity;

    cacheMap = new LinkedHashMap<>(capacity,0.75f,true);
}

public synchronized void put(K k,V v){
    cacheMap.put(k,v);

    // 移除第一个元素
    if(cacheMap.size() > capacity){
        K first = this.keyIterator().next();

        cacheMap.remove(first);
    }
}

public synchronized V get(K k){
    return cacheMap.get(k);
}

public Iterator<K> keyIterator(){
    return cacheMap.keySet().iterator();
}

}
验证：

public static void main(String[] args) {
    LRUCache lruCache = new LRUCache(5);

    lruCache.put("1","a");
    lruCache.put("2","b");
    lruCache.put("3","c");
    lruCache.put("4","d");
    lruCache.put("5","e");

    System.out.println("插入 5 个元素后的顺序");
    println(lruCache);

    // 插入第 6 个元素
    lruCache.put("6","e");

    System.out.println("插入 第 6 个元素后的顺序");
    println(lruCache);

    // 访问 第 3 个元素
    lruCache.get("3");

    System.out.println("访问元素 3 后的顺序");
    println(lruCache);

}

private static void println(LRUCache lruCache){
    for(Iterator it = lruCache.keyIterator(); it.hasNext();){
        System.out.print(it.next() + "    ");
    }
    System.out.println();
}

运行结果如下：

插入 5 个元素后的顺序
1 2 3 4 5
插入 第 6 个元素后的顺序
2 3 4 5 6
访问元素 3 后的顺序
2 4 5 6 3
组合的方式也显得非常简单，有两点需要注意：

保证每个方法的线程安全
put 时，需要查看当前容量是否超过设置的容量，超过则需要删除第一个元素。当然小编这种是实现方式不是很优雅，这么做知识为了能够更加好阐述 LRU 的实现。更好的方案是在构造 LinkedHashMap 时，重写 removeEldestEntry()，如下：
cacheMap = new LinkedHashMap<K,V>(capacity,0.75f,true){
@Override
protected boolean removeEldestEntry(Map.Entry eldest) {
return size()>capacity;
}
};
链表 + HashMap 实现
我们想想，在不利用现存数据结构的条件（如 LinkedHashMap）如何实现一个 LRU 呢？缓存部分容易实现，我们都知道利用 HashMap 即可，但是如何实现缓存容量不足时丢弃最不常用的数据的功能？

利用时间戳。每一个访问，增加的元素我们都给其更新一个时间戳，在 put 的时候，检查，删除时间戳最小的就可以了。这种方法可以实现，但是代价较高，就是我们需要遍历整个数据，得到最小的时间戳。
我们可以换位思考，我们其实不需要关注每个节点的增加或者遍历时间，我们只需要知道那个节点是最先访问就可以了，所以我们可以利用链表记录访问记录，有新数据加入时放在链表的 head 节点，每次访问也将该数据放在 head 节点，那么链表的 tail 一定是最早访问的节点，所以每次当容量不足的时候删除 tail 节点数据并将它的前驱节点设置为 tail 就可以了。注意，这个链表是一个双向链表。代码如下：
public class LinkedLRUCache<K,V> {

private int capacity;

private Map<K,LRUNode> map;

private LRUNode head;

private LRUNode tail;

LinkedLRUCache(int capacity){
    this.capacity = capacity;
    this.map = new HashMap<>();
}

public synchronized void put(K k,V v){
    LRUNode node = map.get(k);

    // 存在该 key，将节点的设置为 head
    if(node != null){
        node.value = v;

        remove(node,false);
    }else{
        /**
         * 该节点不存在
         * 1、将该节点加入缓存
         * 2、设置该节点为 head
         * 3、判断是否超出容量
         */
        node = new LRUNode(k,v);

        if(map.size() >= capacity){
            //删除 tail 节点
            remove(tail,true);
        }

        map.put(k,node);

        setHead(node);
    }

    // 设置当前节点为首节点
    setHead(node);
}

public Object get(String key) {
    LRUNode node = map.get(key);
    if (node != null) {
        // 将刚操作的元素放到head
        remove(node, false);
        setHead(node);
        return node.value;
    }
    return null;
}

/**
 * 设置头结点
 *
 * @param node
 */
private void setHead(LRUNode node) {
    if(head != null){
        node.next = head;
        head.prev = node;
    }

    head = node;

    if(tail == null){
        tail = node;
    }
}

/**
 * 从链表中删除此Node
 *
 * @param node
 * @param flag  为 true 就删除该节点的 key
 */
private void remove(LRUNode node,boolean flag) {
    if (node.prev != null) {
        node.prev.next = node.next;
    } else {
        head = node.next;
    }
    if (node.next != null) {
        node.next.prev = node.prev;
    } else {
        tail = node.prev;
    }
    node.next = null;
    node.prev = null;
    if (flag) {
        map.remove(node.key);
    }
}

private Iterator iterator(){
    return map.keySet().iterator();
}

private class LRUNode<K,V> {

    /**
     * cache 的 key
     */
    private K key;

    /**
     * cache 的 value
     */
    private V value;

    private LRUNode next;

    private LRUNode prev;

    LRUNode(K key, V value) {
        this.key = key;
        this.value = value;
    }
}

}
验证

public static void main(String[] args){
LRUCache lruCache = new LRUCache(5);

    lruCache.put("1","a");
    lruCache.put("2","b");
    lruCache.put("3","c");
    lruCache.put("4","d");
    lruCache.put("5","e");
   
    System.out.println("插入 5 个元素");
    println(lruCache);

    System.out.println("插入 3 元素");
    lruCache.put("3","c");
    println(lruCache);

    System.out.println("插入第  6 个元素");
    lruCache.put("6","f");
    println(lruCache);

    System.out.println("访问 4 元素");
    lruCache.get("4");
    println(lruCache);
}

private static void println(LRUCache lruCache){
    Iterator iterator = lruCache.keyIterator();
    while (iterator.hasNext()){
        System.out.print(iterator.next() + "    ");
    }
    
    System.out.println();
}

执行结果：

插入 5 个元素
1 2 3 4 5
插入 3 元素
1 2 4 5 3
插入第 6 个元素
2 4 5 3 6
访问 4 元素
2 5 3 6 4
mosfet驱动芯片https://www.zg886.cn

福伴
关注
如何使用 LinkedHashMap 实现 LRU 缓存？
java_beautiful的博客
11-14 688
缓存是提高数据读取性能的通用技术，在硬件和软件设计中被广泛使用，例如CPU 缓存、Glide 内存缓存，数据库缓存等。由于缓存空间不可能无限大，当缓存容量占满时，就需要利用某种策略将部分数据换出缓存，这就是缓存的替换策略 / 淘汰问题。使用一个随机数生成器随机地选择要被淘汰的数据块；记录各个数据块的访问时间，最早访问的数据最先被淘汰；记录各个数据块的访问“时间戳”，最近最久未使用的数据最先被淘汰。
使用LinkedHashMap实现简单的LRU
浪丶荡
09-22 951
LRU在很多缓存失效策略中会涉及，本质是一种节约更公平的节约资源策略，最近最少使用 java中的LinkedHashMap就有自带的实现LRU 简单说一下LinkedHashMap这种数据结构，本质是HashMap+双向链表，不仅有HashMap的特性，还能维护元素的顺序，示意图如下 使用LinkedHashMap实现简单的LRU package cn.com.suntree.utils.myself; import java.util.LinkedHashMap; import java.util.M
Java-LinkedHashMap
莫失莫忘的博客
01-23 1633
一、介绍 LinkedHashMap 继承 了 HashMap。LinkedHashMap实现与HashMap的不同之处在于，后者维护着一个运行于所有条目的双重链接列表。此链接列表定义了迭代顺序，该迭代顺序可以是插入顺序或者是访问顺序。具有一定的顺序性。 HashMap可以参考之前的文章：https://so.csdn.net/so/search?q=HashMap&t=blog&u=weixin_43732955 public class LinkedHashMap<K,V&gt
JUC并发编程之HashMap(jdk1.7版本)-底层源码探究
Eriksen的博客
03-10 643
JUC并发编程之HashMap(jdk1.7版本)-底层源码探究
两个常用Map（LinkedHashMap和ConcurrentHashMap）+Map集合的遍历+Map集合中常用方法（getOrDefault()、putIfAbsent()和merge()）
Watermelon_Mr的博客
09-10 216
三、Map集合中的getOrDefault()、putIfAbsent()和merge()2、方法二：使用value的Collection集合遍历。（1）特点：元素被放入的顺序与元素被遍历取出的顺序一致。1、getOrDefault()：Map集合中。2、putIfAbsent()：Map集合中。3、方法三：使用Entry的Set集合遍历。1、方法一：使用key的Set集合遍历。（1）特点：单独拿键值，单独拿值。3、merge()：Map集合中。则将此新键值对添加到Map集合中。
LinkedHashMap如何获取第一个键值
u010217620的博客
03-13 3703
每天坚持输出，哪怕很小的知识点 @Test public void test_LinkedHashMap_findFirstKey(){ LinkedHashMap<String,String> linkedHashMap = new LinkedHashMap<>(); linkedHashMap.put("1","1"); linkedHashMap.put("2","2”); // 关键代码
Java LinkedHashMap获取第一个或最后一个条目
热门推荐
liaojiede的博客
02-01 1万+
Java LinkedHashMap获取第一个或最后一个条目 问题 我使用了LinkedHashMap，因为重要的是键在 Map 中输入的顺序。 但是现在我想首先获得key的值(第一个输入的条目)或者最后一个。 应该有类似first()和last()之类的方法吗？ 我是否需要一个迭代器来获取第一个键入口？这就是为什么我用了LinkedHashMap！ 谢谢！ #1 热门回答(120 赞) Link...
剖析 LinkedHashMap
sinat_41653656的博客
12-10 721
剖析 LinkedHashMap1. LinkedHashMap2. 实现原理2.1 内部组成2.2 构造方法2.3 添加元素2.4 获取元素2.5 删除键值对2.6 iterator3. 总结 1. LinkedHashMap LinkedHashMap 是 HashMap 的子类，但内部还有一个双向链表维护键值对的顺序，每个键值对既位于哈希表中，也位于这个双向链表中。LinkedHashMap 支持两种顺序：一种是插入顺序，另一种是访问顺序。 插入顺序：先插入的在前面，后插入的在后
redis缓存淘汰策略-基于LinkedHashMap实现LRU算法
ywl470812087的博客
01-02 768
2.3如果容量(坑位)满了要删除最不长用的数据，每次新访问还要把新的数据插入到队头(按照业务你自己设定左右那一边是队头)LRU是Least Recently Used的缩写，即最近最少使用，是一种常用的页面置换算法，2.1必须要有顺序之分，一区分最近使用的和很久没有使用的数据排序。必须要有读+写两个操作，按照命中率的思路考虑，写操作+读操作时间复杂度都需要为O(1)当添加第四个数据进来，这时候就会将1挤出去，淘汰1。如果一次就可以找到，你觉得什么数挑结构最合适?选择最近最久未使用的数据予以淘汰。
基于LinkedHashMap实现FIFO(先进先出)淘汰算法
weixin_42490383的博客
03-20 712
package com.bingo.frame; import java.util.LinkedHashMap; /** * b.基于LinkedHashMap实现FIFO(先进先出)淘汰算法 * @author bingo */ public class BingoTest { class SimpleFIFOCache extends LinkedHashMap<Object, Object> { private int maxCap; public Simpl
LinkedHashMap实现解析
我们的征途是星辰大海
01-01 778
1，基本核心结构 LinkedHashMap继承HashMap，除了有那些HashMap内部的结构外，还定义了 一个双向链表， /** * HashMap.Node subclass for normal LinkedHashMap entries. */ static class Entry<K,V> extends HashMap.Node<K,V> { Entry<K,V> before, after; Entry(int hash, K ke
LinkedHashMap（有序 map）获取第一个元素和最后一个元素
哇哇哇，真的学到了！！！
05-05 7491
获取LinkedHashMap中的头部元素（最早添加的元素）：时间复杂度O(1) public <K, V> Entry<K, V> getHead(LinkedHashMap<K, V> map) { return map.entrySet().iterator().next(); } 获取LinkedHashMap中的末尾元素（最近添加的元素）：时间复杂度O(n) public <K, V> Entry<K, V> getTa
记录插入顺序用linkedHashMap
越努力越幸运~~ Java领域从业者；CSDN新兴创新博主；Java领域优质创作者；书写奋斗者故事;欢迎交流学习进步；
12-21 984
LinkedHashMap是HashMap的一个子类，保存了记录的插入顺序，在用iterator遍历时，先得到的记录是先插入的。 也可以在构造函数中带参数，来调整排序。 》》》说说LinkedHashSet
LinkedHashMap
qq_36409043的博客
02-23 5724
概念 LinkedHashMap继承自HashMap，它的结构如图所示： hashmap是无序的，LinkedHashMap是有序的，且默认为插入顺序。 LinkedHashMap通过在HashMap的基础上增加一条双向链表，实现了插入顺序和访问顺序一致。通过对HashMap一些方法的覆盖,例如newNode, replacementNode, replacementTreeNode, newTreeNode，让所有对底层HashMap数据结构修改的同时该链表进行修改,遍历的时候便是遍历这一条有序
LinkedHashMap用法详解
jpfice的博客
02-22 7204
LinkedHashMap用法详解
LeetCode 第 19 号问题：删除链表的倒数第 N 个节点
程序员吴师兄的博客
05-04 226
本文首发于公众号「五分钟学算法」，是图解 LeetCode 系列文章之一。 个人网站：https://www.cxyxiaowu.com 题目来源于 LeetCode 上第 19 号问题：删除链表的倒数第 N 个节点。题目难度为 Medium，目前通过率为 34.4% 。 题目描述 给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。 ...
[Java基础要义]HashMap、LinkedHashMap元素遍历机制探讨
tanghuan0827的博客
12-03 1529
Map作为键值对Entry<K,V>的的容器，对其内部 键值对Entry<K,V> 的遍历总归是要有一个顺序的。 本文重点讨论HashMap及其子类LinkedHashMap的遍历机制，总结出两者的特点和适用情况。 CSDN-2014博客之星投票啦 CSDN-2014博客之星评选开始啦，如果您觉得我的文章对您有所帮助，请您点击左边栏的图片投我一票，您的支持是我分享知识的强大动力！ 1.HashMap的遍历机制 ...
linkedhashmap获取第n个元素_听说同学你搞不懂Java的LinkedHashMap，可笑
weixin_39603995的博客
11-29 1920
转载于：公众号：沉默王二(ID：cmower)同学们好啊，还记得 HashMap 那篇吗？我自己感觉写得非常棒啊，既通俗易懂，又深入源码，真的是分析得透透彻彻、清清楚楚、明明白白的。(一不小心又上仨成语？)HashMap 哪哪都好，真的，只要你想用键值对，第一时间就应该想到它。但俗话说了，“金无足赤人无完人”，HashMap 也不例外。有一种需求它就满足不了，假如我们需要一个按照插入顺序来排列的键...
自定义实现自动清理最老元素LinkedHashMap的LRU
奔跑的菜鸡
12-24 1465
自定义class重写元素上限方法 package com.felix.spring_cloud_one.util; import java.util.LinkedHashMap; import java.util.Map; public class LruLinkedHashMap<K,V> extends LinkedHashMap<K,V> { private final int maxCapacity; private static final float
LRU 用 LinkedHashMap 实现
最新发布
10-11
LinkedHashMap 是 Java 中的一个内置类，非常适合用来实现 LRU 缓存。LinkedHashMap 继承自 HashMap，并添加了链表结构，可以记住元素插入的顺序。 以下是使用 LinkedHashMap 实现 LRU 缓存的基本步骤： 1. 创建 ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值