LFU算法在Java中的实现

2023-11-29 10:08:54

LFU算法简介

LFU算法是一种缓存算法，它根据数据的访问频率来决定哪些数据应该被缓存。LFU算法的核心思想是将数据按照访问频率从小到大排序，当缓存已满时，将最少访问的数据从缓存中删除。LFU算法的时间复杂度为O(1)，这使得它非常适合用于处理大量数据的场景。

LFU算法的实现

LFU算法的实现需要使用三个Map：

freqMap：该Map将数据的访问频率作为键，将数据本身作为值。
recencyMap：该Map将数据本身作为键，将数据的最近访问时间作为值。
minFreqMap：该Map将访问频率作为键，将数据本身作为值。

LFU算法的get方法：

从freqMap中获取数据的访问频率。
如果freqMap中不存在该数据，则将其添加到freqMap中，并将其访问频率设置为1。
将数据的最近访问时间更新为当前时间，并将其添加到recencyMap中。
如果缓存已满，则从freqMap中获取访问频率最小的数据，并将其从缓存中删除。

LFU算法的put方法：

将数据添加到缓存中。
将数据的访问频率更新为当前时间，并将其添加到recencyMap中。
如果缓存已满，则从freqMap中获取访问频率最小的数据，并将其从缓存中删除。

LFU算法的示例代码

import java.util.HashMap;
import java.util.Map;

public class LFUCache {

    private Map<Integer, Integer> freqMap;
    private Map<Integer, Integer> recencyMap;
    private Map<Integer, Integer> minFreqMap;
    private int capacity;

    public LFUCache(int capacity) {
        this.freqMap = new HashMap<>();
        this.recencyMap = new HashMap<>();
        this.minFreqMap = new HashMap<>();
        this.capacity = capacity;
    }

    public int get(int key) {
        if (!freqMap.containsKey(key)) {
            return -1;
        }

        int freq = freqMap.get(key);
        freqMap.put(key, freq + 1);
        recencyMap.put(key, System.currentTimeMillis());

        if (freq > 1) {
            minFreqMap.remove(freq - 1);
        }
        minFreqMap.put(freq, key);

        return key;
    }

    public void put(int key, int value) {
        if (capacity <= 0) {
            return;
        }

        if (freqMap.containsKey(key)) {
            freqMap.put(key, freqMap.get(key) + 1);
            recencyMap.put(key, System.currentTimeMillis());
            return;
        }

        if (freqMap.size() == capacity) {
            int minFreq = Collections.min(minFreqMap.keySet());
            int keyToRemove = minFreqMap.get(minFreq);
            freqMap.remove(keyToRemove);
            recencyMap.remove(keyToRemove);
            minFreqMap.remove(minFreq);
        }

        freqMap.put(key, 1);
        recencyMap.put(key, System.currentTimeMillis());
        minFreqMap.put(1, key);
    }

    public static void main(String[] args) {
        LFUCache cache = new LFUCache(2);

        cache.put(1, 1);
        cache.put(2, 2);
        cache.get(1);
        cache.put(3, 3);
        cache.get(2);
        cache.get(3);
        cache.put(4, 4);
        cache.get(1);
        cache.get(3);
        cache.get(4);

        System.out.println(cache.get(3));
        System.out.println(cache.get(2));
        System.out.println(cache.get(1));
        System.out.println(cache.get(4));
    }
}