java实现lru缓存

什么是LRU缓存？ (What is LRU Cache?)

LRU Cache stands for Least Recently Used Cache. The size of the cache is fixed and it supports get() and put() operations. When the cache is full, the put() operation removes the least recently used cache.

LRU缓存代表“最近最少使用的缓存”。 缓存的大小是固定的，并且支持get（）和put（）操作。 当缓存已满时，put（）操作将删除最近最少使用的缓存。

如何在Java中实现LRU Cache？ (How to implement LRU Cache in Java?)

The LRU cache can be implemented in Java using two data structures – HashMap and a doubly-linked list to store the data.

LRU高速缓存可以使用两个数据结构-HashMap和一个用于存储数据的双向链接列表来用Java实现。

The idea is to always have the elements in the following order.

想法是始终按以下顺序排列元素。

Here is the LRUCache implementation in Java.

这是Java中的LRUCache实现。

package com.journaldev.examples;import java.util.HashMap;
import java.util.Map;public class LRUCache<K, V> {private Node<K, V> lru;private Node<K, V> mru;private Map<K, Node<K, V>> container;private int capacity;private int currentSize;public LRUCache(int capacity) {this.capacity = capacity;this.currentSize = 0;lru = new Node<K, V>(null, null, null, null);mru = lru;container = new HashMap<K, Node<K, V>>();}public V get(K key) {Node<K, V> tempNode = container.get(key);if (tempNode == null) {return null;}// If MRU leave the list as it iselse if (tempNode.key == mru.key) {return mru.value;}// Get the next and prev nodesNode<K, V> nextNode = tempNode.next;Node<K, V> prevNode = tempNode.prev;// If at the left-most, we update LRUif (tempNode.key == lru.key) {nextNode.prev = null;lru = nextNode;}// If we are in the middle, we need to update the items before and after our// itemelse if (tempNode.key != mru.key) {prevNode.next = nextNode;nextNode.prev = prevNode;}// Finally move our item to the MRUtempNode.prev = mru;mru.next = tempNode;mru = tempNode;mru.next = null;return tempNode.value;}public void put(K key, V value) {if (container.containsKey(key)) {return;}// Put the new node at the right-most end of the linked-listNode<K, V> myNode = new Node<K, V>(mru, null, key, value);mru.next = myNode;container.put(key, myNode);mru = myNode;// Delete the left-most entry and update the LRU pointerif (currentSize == capacity) {container.remove(lru.key);lru = lru.next;lru.prev = null;}// Update container size, for the first added entry update the LRU pointerelse if (currentSize < capacity) {if (currentSize == 0) {lru = myNode;}currentSize++;}}// Node for doubly linked listclass Node<T, U> {T key;U value;Node<T, U> prev;Node<T, U> next;public Node(Node<T, U> prev, Node<T, U> next, T key, U value) {this.prev = prev;this.next = next;this.key = key;this.value = value;}}}

Some important points about the implementation.

有关实施的一些重要点。

• The Node class is used to implement doubly linked list structure. It has references to the previous and next node.Node类用于实现双向链表结构。 它具有对上一个和下一个节点的引用。
• When we are getting a value using the get() method, the element is moved to the rightmost position because it becomes MRU element.当我们使用get（）方法获取值时，该元素将移动到最右边的位置，因为它成为MRU元素。
• When we are putting an element in the cache, it’s added to the rightmost side. If the container is full, then the LRU element is removed.当我们将元素放入缓存时，它会添加到最右侧。 如果容器已满，则将删除LRU元素。
• We are using Generics so that we can use the implementation with any types of data.我们正在使用泛型，以便我们可以将实现与任何类型的数据一起使用。

LRUCache测试程序 (LRUCache Test Program)

I am using JUnit test cases to run some scenarios from the LeetCode question.

我正在使用JUnit测试用例来运行LeetCode问题中的某些方案。

package com.journaldev.examples;import static org.junit.jupiter.api.Assertions.assertEquals;import org.junit.jupiter.api.Test;class LRUCacheTest {private LRUCache<Integer, Integer> c;public LRUCacheTest() {this.c = new LRUCache<>(2);}@Testpublic void testCacheStartsEmpty() {assertEquals(c.get(1), null);}@Testpublic void testSetBelowCapacity() {c.put(1, 1);assertEquals(c.get(1), 1);assertEquals(c.get(2), null);c.put(2, 4);assertEquals(c.get(1), 1);assertEquals(c.get(2), 4);}@Testpublic void testCapacityReachedOldestRemoved() {c.put(1, 1);c.put(2, 4);c.put(3, 9);assertEquals(c.get(1), null);assertEquals(c.get(2), 4);assertEquals(c.get(3), 9);}@Testpublic void testGetRenewsEntry() {c.put(1, 1);c.put(2, 4);assertEquals(c.get(1), 1);c.put(3, 9);assertEquals(c.get(1), 1);assertEquals(c.get(2), null);assertEquals(c.get(3), 9);}}

LRUCache Test

LRUCache测试

结论 (Conclusion)

There are many ways to implement LRU Cache. But, if we keep the cache elements in the order of their usage, then we can get better performance in the put() operation.

有很多方法可以实现LRU缓存。 但是，如果我们按照缓存元素的使用顺序进行排序，则可以在put（）操作中获得更好的性能。

参考资料 (References)

• StackOverflow QuestionStackOverflow问题
• Quora DiscussionQuora讨论

翻译自: https://www.journaldev.com/32688/lru-cache-implementation-in-java

java实现lru缓存