Java实现LRU Cache的两种方法

方法一

完全使用Java的LinkedHashMap来实现。实现也有两种方法,一种使用继承,另一种使用组合,这里给出使用组合的代码。

public class LRUCache<K, V> {
    private Map<K, V> map;
    private final int cacheSize;

    public LRUCache(int initialCapacity) {
        map = new LinkedHashMap<K, V>(initialCapacity, 0.75f, true) {
            @Override
            protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
                return size() > cacheSize;
            }
        };
        this.cacheSize = initialCapacity;
    }
}

核心部分在LinkedHashMap的第三个构造函数上,要把这个构造参数accessOrder设为true,代表LinkedHashMap内部维持访问顺序。另外,还需要重写removeEldestEntry(),这个函数如果返回true,代表应该把最久未被访问的节点移除。

这里记录一下LinkedHashMap的三个方法:

  • void afterNodeAccess(Node<K,V> p) {}
  • void afterNodeInsertion(boolean evict) {}
  • void afterNodeRemoval(Node<K,V> p) {}

这三个方法在HashMap中就有,而且为空;LinkedHashMap继承了HashMap,并重写了这三个方法。下面是LinkedHashMap中这三个函数的作用。

afterNodeAccess方法

作用:将目前访问的节点放到链表最后。

调用位置

  • get方法中,如果accessOrder设为true,调用该方法。
  • put方法中,如果当前插入的值已经在Map中,调用该方法。
afterNodeInsertion方法

作用:如果removeEldestEntry函数返回true,那么该方法就把最久未被访问的节点删除。

调用位置:在put方法中,如果当前插入的值不在Map中,调用该方法。

afterNodeRemoval方法

作用:移除节点后,维护该节点前后双向链表的关系。

调用位置Mapremove方法中

方法二

自己实现。其中代码是从 LeetCode 146. LRU Cache 上摘下来的。代码里面有注释。

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 在链头放最久未被使用的元素,链尾放刚刚添加或访问的元素
 */
class LRUCache {
    class Node {
        int key, value;
        Node pre, next;

        Node(int key, int value) {
            this.key = key;
            this.value = value;
            pre = this;
            next = this;
        }
    }

    private final int capacity;// LRU Cache的容量
    private Node dummy;// dummy节点是一个冗余节点,dummy的next是链表的第一个节点,dummy的pre是链表的最后一个节点
    private Map<Integer, Node> cache;//保存key-Node对,Node是双向链表节点

    public LRUCache(int capacity) {
        this.capacity = capacity;
        dummy = new Node(0, 0);
        cache = new ConcurrentHashMap<>();
    }

    public int get(int key) {
        Node node = cache.get(key);
        if (node == null) return -1;
        remove(node);
        add(node);
        return node.value;
    }

    public void put(int key, int value) {
        Node node = cache.get(key);
        if (node == null) {
            if (cache.size() >= capacity) {
                cache.remove(dummy.next.key);
                remove(dummy.next);
            }
            node = new Node(key, value);
            cache.put(key, node);
            add(node);
        } else {
            cache.remove(node.key);
            remove(node);
            node = new Node(key, value);
            cache.put(key, node);
            add(node);
        }
    }

    /**
     * 在链表尾部添加新节点
     *
     * @param node 新节点
     */
    private void add(Node node) {
        dummy.pre.next = node;
        node.pre = dummy.pre;
        node.next = dummy;
        dummy.pre = node;
    }

    /**
     * 从双向链表中删除该节点
     *
     * @param node 要删除的节点
     */
    private void remove(Node node) {
        node.pre.next = node.next;
        node.next.pre = node.pre;
    }
}
  • 1
    点赞
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java LRU(Least Recently Used)缓存是一种常见的缓存策略,用于在内存中存储最近被访问的数据以提高访问速度。LRU缓存基于一种简单的原则,即最近被访问的数据很可能会在将来被再次访问,因此将最近被访问的数据保留在缓存中。 在Java实现LRU缓存通常使用LinkedHashMap实现LinkedHashMap是HashMap的一个子类,它保留了元素的插入顺序。通过使用LinkedHashMap中的accessOrder参数来设置LRU顺序,可以使得最近被访问的元素排在最前面,从而方便实现LRU缓存。 当需要访问缓存中的数据时,首先在缓存中查找该数据。如果查找成功,则表示缓存命中,将该数据移动到LinkedHashMap的末尾,即使其成为最新被访问的数据。如果查找失败,则需要从数据源中获取数据,并将其放入缓存中。 然而,使用普通的LinkedHashMap实现LRU缓存存在一个问题,那就是无法限制缓存的大小。为了解决这个问题,可以通过继承LinkedHashMap并重写removeEldestEntry方法实现缓存的大小限制。在put操作时,判断缓存中的元素是否超过最大值,如果超过则删除最老的元素。 总之,Java中的LRU缓存是一种非常实用的数据存储方式,可以通过LinkedHashMap的accessOrder参数和重写removeEldestEntry方法实现。这种缓存机制可以有效地提高数据访问的速度,对于需要频繁访问的数据非常有用。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值