实现一个LRU（最近最少使用）缓存可以通过使用HashMap和双向链表来实现。HashMap用于快速查找缓存中的元素，而双向链表用于维护元素的使用顺序实现思路：
1.使用HashMap存储键值对，以便快速访问。
2.使用双向链表维护元素的使用顺序，最近使用的元素放在链表头部，最少使用的元素放在链表尾部。
3. 每次访问或插入元素时，将该元素移动到链表头部。
4.当缓存容量达到上限时，移除链表尾部的元素。
5. 定义一个内部类 Node，用于表示缓存中的每个元素。
java
package com.huawei.od.huawei.algorithm;
import java.util.HashMap;
/**
* @ClassName: LRUCache缓存实现
* @author: zengxianjin
* @Desc: 实现一个LRU（最近最少使用）缓存可以通过使用HashMap和双向链表来实现。HashMap用于快速查找缓存中的元素，而双向链表用于维护元素的使用顺序
* @create: 2024-09-03 16:39
* @version: V1.0
**/
public class LRUCache缓存实现 {
// 使用HashMap存储键值对，以便快速访问。
// 使用双向链表维护元素的使用顺序，最近使用的元素放在链表头部，最少使用的元素放在链表尾部。
// 每次访问或插入元素时，将该元素移动到链表头部。
// 当缓存容量达到上限时，移除链表尾部的元素。
// 定义一个内部类 CacheNode，用于表示缓存中的每个元素。
private class CacheNode {
int key; // 键
int value; // 值
CacheNode prev; // 指向前一个节点的引用
CacheNode next; // 指向后一个节点的引用
// Node 类的构造函数，初始化键和值。
CacheNode(int key, int value) {
this.key = key;
this.value = value;
}
}
// LRUCache 类的成员变量。
private final int capacity; // 缓存的最大容量
private final HashMap<Integer, CacheNode> map; // 用于存储键和对应节点的映射
private final CacheNode head; // 双向链表的头部哨兵节点
private final CacheNode tail; // 双向链表的尾部哨兵节点
// LRUCache 类的构造函数，初始化缓存容量和映射，并设置哨兵节点。
public LRUCache缓存实现(int capacity) {
this.capacity = capacity;
this.map = new HashMap<>();
this.head = new CacheNode(0, 0); // 初始化头部哨兵节点
this.tail = new CacheNode(0, 0); // 初始化尾部哨兵节点
head.next = tail; // 头部哨兵节点指向尾部哨兵节点
tail.prev = head; // 尾部哨兵节点指向头部哨兵节点
}
// get 方法，用于获取键对应的值。
public int get(int key) {
CacheNode node = map.get(key); // 从映射中获取节点
if (node == null) {
return -1; // 如果节点不存在，返回 -1
}
moveToHead(node); // 将节点移动到链表头部
return node.value; // 返回节点的值
}
// put 方法，用于插入或更新键值对。
public void put(int key, int value) {
CacheNode node = map.get(key); // 从映射中获取节点
if (node == null) {
CacheNode newNode = new CacheNode(key, value); // 如果节点不存在，创建新节点
map.put(key, newNode); // 将新节点添加到映射中
addNode(newNode); // 将新节点添加到链表头部
if (map.size() > capacity) { // 如果映射的大小超过容量，移除尾部节点
CacheNode tail = popTail(); // 移除链表尾部节点
map.remove(tail.key); // 从映射中移除对应的键
}
} else {
node.value = value; // 如果节点存在，更新节点的值
moveToHead(node); // 将节点移动到链表头部
}
}
// addNode 方法，用于将节点添加到链表头部。
private void addNode(CacheNode node) {
node.prev = head; // 设置节点的前驱为头部哨兵节点
node.next = head.next; // 设置节点的后继为头部哨兵节点的后继
head.next.prev = node; // 将头部哨兵节点的后继的前驱设置为新节点
head.next = node; // 将头部哨兵节点的后继设置为新节点
}
// removeNode 方法，用于从链表中移除节点。
private void removeNode(CacheNode node) {
CacheNode prev = node.prev; // 获取节点的前驱
CacheNode next = node.next; // 获取节点的后继
prev.next = next; // 将节点的前驱的后继设置为节点的后继
next.prev = prev; // 将节点的后继的前驱设置为节点的前驱
}
// moveToHead 方法，用于将节点移动到链表头部。
private void moveToHead(CacheNode node) {
removeNode(node); // 首先从链表中移除节点
addNode(node); // 然后将节点添加到链表头部
}
// popTail 方法，用于移除链表尾部的节点。
private CacheNode popTail() {
CacheNode res = tail.prev; // 获取尾部哨兵节点的前驱，即链表尾部的节点
removeNode(res); // 从链表中移除节点
return res; // 返回被移除的节点
}
// main 方法，用于演示 LRUCache 的使用。
public static void main(String[] args) {
LRUCache缓存实现 cache = new LRUCache缓存实现(2); // 创建一个容量为 2 的 LRU 缓存
cache.put(1, 3); // 插入键值对 (1, 3)
cache.put(2, 4); // 插入键值对 (2, 4)
System.out.println(cache.get(1)); // 获取键 1 的值，返回 3
cache.put(3, 1); // 插入键值对 (3, 1)，导致键 2 被淘汰
System.out.println(cache.get(2)); // 获取键 2 的值，返回 -1（未找到）
cache.put(4, 7); // 插入键值对 (4, 4)，导致键 1 被淘汰
System.out.println(cache.get(1)); // 获取键 1 的值，返回 -1（未找到）
System.out.println(cache.get(3)); // 获取键 3 的值，返回 1
System.out.println(cache.get(4)); // 获取键 4 的值，返回 7
}
}时间复杂度：
get和put操作的时间复杂度均为O(1)。