LRU缓存机制（LInkedHashMap实现）

题目

运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制 。
实现 LRUCache 类：

• LRUCache(int capacity) ：以正整数作为容量 capacity 初始化 LRU 缓存
• int get(int key) ：如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。
• void put(int key, int value) ：如果关键字已经存在，则变更其数据值；如果关键字不存在，则插入该组「关键字-值」。当缓存容量达到上限时，它应该在写入新数据之前删除最久未使用的数据值，从而为新的数据值留出空间。

进阶：你是否可以在 O(1) 时间复杂度内完成这两种操作？

示例：
输入
[“LRUCache”, “put”, “put”, “get”, “put”, “get”, “put”, “get”, “get”, “get”]
[[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]
输出
[null, null, null, 1, null, -1, null, -1, 3, 4]

解释
LRUCache lRUCache = new LRUCache(2);
lRUCache.put(1, 1); // 缓存是 {1=1}
lRUCache.put(2, 2); // 缓存是 {1=1, 2=2}
lRUCache.get(1); // 返回 1
lRUCache.put(3, 3); // 该操作会使得关键字 2 作废，缓存是 {1=1, 3=3}
lRUCache.get(2); // 返回 -1 (未找到)
lRUCache.put(4, 4); // 该操作会使得关键字 1 作废，缓存是 {4=4, 3=3}
lRUCache.get(1); // 返回 -1 (未找到)
lRUCache.get(3); // 返回 3
lRUCache.get(4); // 返回 4

提示：

• 1 <= capacity <= 3000
• 0 <= key <= 3000
• 0 <= value <= 104
• 最多调用 3 * 104 次 get 和 put

注意点

1、LinkedHashMap是有序的，当accessOrder为false时，为插入有序（默认）；当accessOrder为true时，为访问有序；（LinkedHashMap维护一个双向链表实现有序）
2、所以我们可以改写LinkedHashMap来实现LRU策略；
源码：

• 构造器
  
• getOrDefault(Object key, V defaultValue)：获取key对应的值，不存在则返回默认值。
  
• afterNodeAccess(Node<K,V> e)：将节点e移动到双向链表的末尾（只有当LinkedHashMap为访问有序时才执行）
  
• put(K key, V value)：修改key的值，如果key存在，则修改key对应的值；如果key不存在，则插入该key。
  
• putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict)：作用同put方法
  
• afterNodeInsertion(boolean evict)：移除双向链表中最老的节点，LinkedHashMap默认不移除。（重点）
  
• removeEldestEntry(Map.Entry<K,V> eldest)：默认返回false，我们只需要将该条件设置为超出缓存容量就删除最老元素，即可实现LRU。
  

实现

// 继承LinkedHashMap，根据LinkedHashMap的有序性实现LRU（访问有序）
class LRUCache extends LinkedHashMap<Integer, Integer> {

	// LRU缓存
    private int capicity;

    public LRUCache(int capacity) {
    	// 第一个参数为：初始容量；第二个参数为：负载因子；
    	// 第三个参数为：顺序模式（true：表示访问有序，false：表示插入有序）
        super(capacity, 0.75F, true);
        this.capicity = capacity;
    }
    
    public int get(int key) {
    	// 获取key对应的值，不存在返回 -1
        return super.getOrDefault(key, -1);
    }
    
    public void put(int key, int value) {
    	// 修改key的值，如果key存在，则修改key对应的值；如果key不存在，则插入该key。
        super.put(key, value);
    }

	// 重点，重写该方法实现LRU策略（LinkedHashMap一直返回false）
    @Override
    protected  boolean removeEldestEntry(Map.Entry<Integer, Integer> eldest) {
    	// 当缓存容量达到上限时，删除最久未使用的数据值，从而为新的数据值留出空间。 
        return size() > capicity;
    }
}

本文地址：https://blog.csdn.net/weixin_43857345/article/details/110874494