自定义实现LRU缓存的方法是基于双向链表和哈希表的数据结构。双向链表用于维护页的访问顺序，而哈希表用于实现对页面的快速查找。
- 创建一个名为LRUCache的泛型类，用于表示LRU缓存。构造方法中需要指定缓存的容量。
class LRUCache<K, V> {
private int capacity;
// 哈希表用于快速查找页面
private Map<K, Node> map;
// 双向链表用于维护页面的访问顺序
private Node head;
private Node tail;
// ...
}
- 创建一个名为Node的内部类，用于表示双向链表中的节点。节点包含键（key）和值（value），以及指向前一个节点和后一个节点的引用。
private class Node {
K key;
V value;
Node prev;
Node next;
Node(K k, V v) {
key = k;
value = v;
}
}
- 在构造方法中初始化缓存容量、哈希表和链表的头尾节点。
public LRUCache(int capacity) {
this.capacity = capacity;
map = new HashMap<>();
head = new Node(null, null);
tail = new Node(null, null);
head.next = tail;
tail.prev = head;
}
- 实现get方法，用于获取指定键对应的值。如果键存在于缓存中，则将该节点移动到链表头部，并返回对应的值。
public V get(K key) {
Node node = map.get(key);
if (node != null) {
moveToHead(node);
return node.value;
}
return null;
}
- 实现put方法，用于向缓存中存储键值对。如果键已经存在于缓存中，则更新对应节点的值，并将节点移动到链表头部。如果键不存在于缓存中，则创建一个新节点并添加到链表头部，然后判断缓存是否已满，如果已满，则移除链表尾部的节点。
public void put(K key, V value) {
Node node = map.get(key);
if (node != null) {
node.value = value;
moveToHead(node);
} else {
node = new Node(key, value);
map.put(key, node);
addToHead(node);
if (map.size() > capacity) {
Node removed = removeTail();
map.remove(removed.key);
}
}
}
- 实现辅助方法addToHead，用于将节点添加到链表的头部。
private void addToHead(Node node) {
node.prev = head;
node.next = head.next;
head.next.prev = node;
head.next = node;
}
- 实现辅助方法removeNode，用于从链表中移除指定节点。
private void removeNode(Node node) {
Node prev = node.prev;
Node next = node.next;
prev.next = next;
next.prev = prev;
}
- 实现辅助方法moveToHead，用于将节点移动到链表的头部。
private void moveToHead(Node node) {
removeNode(node);
addToHead(node);
}
- 实现辅助方法removeTail，用于移除链表的尾部节点，并返回该节点。
private Node removeTail() {
Node node = tail.prev;
removeNode(node);
return node;
}
通过使用双向链表和哈希表的这种自定义实现，可以根据最近的访问顺序来淘汰最近最少使用的页面。每当访问一个页面时，可以将其移动到双向链表的头部，以保证最新访问的页面总是在链表头部。如果缓存已满，则可以从链表尾部移除最近最少使用的页面，即链表尾部的节点。
请注意，上述代码只是一个基本的实现示例，实际使用时可能需要根据具体需求进行适当的调整和优化。
在Android中可以使用自定义的LRUCache缓存类来存储和获取数据。以下是一个简单的示例：
// 创建一个LRUCache对象，设置缓存容量为3
LRUCache<String, String> cache = new LRUCache<>(3);
// 存储数据到缓存中
cache.put("key1", "value1");
cache.put("key2", "value2");
cache.put("key3", "value3");
// 从缓存中获取数据
String value1 = cache.get("key1"); // value1 = "value1"
String value2 = cache.get("key2"); // value2 = "value2"
String value3 = cache.get("key3"); // value3 = "value3"
// 存储新的数据到缓存中，触发淘汰最久未使用的数据
cache.put("key4", "value4");
// 此时缓存中的数据为：key2 -> key3 -> key4
String value4 = cache.get("key4"); // value4 = "value4"
String value1Again = cache.get("key1"); // value1Again = null，最久未使用的key1已被淘汰
这个示例展示了在Android中使用自定义的LRUCache缓存类进行数据存储和获取的过程。通过指定缓存的容量，在缓存容量已满的情况下，当新的数据被存储时会淘汰最久未使用的数据。这样可以确保缓存中始终保存最近被访问的数据，提高数据访问效率。
