java手动实现lfu

LFU（Least Frequently Used）是一种缓存淘汰算法，可以用于对缓存中的数据进行淘汰。下面是 Java 手动实现 LFU 的示例代码：

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

public class LFUCache<K, V> {
    private Map<K, V> cacheMap; // 存放缓存数据
    private Map<K, Integer> freqMap; // 存放缓存数据的访问频率
    private Map<Integer, LinkedHashSet<K>> freqKeysMap; // 存放访问频率相同的缓存数据
    private int capacity; // 缓存容量
    private int minFreq; // 缓存数据的最小访问频率

    public LFUCache(int capacity) {
        this.cacheMap = new HashMap<>();
        this.freqMap = new HashMap<>();
        this.freqKeysMap = new HashMap<>();
        this.capacity = capacity;
        this.minFreq = 0;
    }

    public V get(K key) {
        V value = cacheMap.get(key);
        if (value == null) {
            return null;
        }

        // 更新缓存数据的访问频率
        int freq = freqMap.get(key) + 1;
        freqMap.put(key, freq);

        // 更新访问频率相同的缓存数据
        freqKeysMap.get(freq - 1).remove(key);
        if (freqKeysMap.get(freq - 1).isEmpty()) {
            freqKeysMap.remove(freq - 1);
            if (minFreq == freq - 1) {
                minFreq++;
            }
        }
        freqKeysMap.computeIfAbsent(freq, k -> new LinkedHashSet<>()).add(key);

        return value;
    }

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

        // 缓存数据已存在，更新其值和访问频率
        if (cacheMap.containsKey(key)) {
            cacheMap.put(key, value);
            get(key);
            return;
        }

        // 缓存容量已满，淘汰访问频率最小的缓存数据
        if (cacheMap.size() >= capacity) {
            K minFreqKey = freqKeysMap.get(minFreq).iterator().next();
            freqKeysMap.get(minFreq).remove(minFreqKey);
            if (freqKeysMap.get(minFreq).isEmpty()) {
                freqKeysMap.remove(minFreq);
            }
            cacheMap.remove(minFreqKey);
            freqMap.remove(minFreqKey);
        }

        // 添加新的缓存数据
        cacheMap.put(key, value);
        freqMap.put(key, 1);
        freqKeysMap.computeIfAbsent(1, k -> new LinkedHashSet<>()).add(key);
        minFreq = 1;
    }
}

这个示例代码中，LFUCache 类实现了 LFU 缓存淘汰算法。在 get 方法中，缓存数据的访问频率会加 1，同时更新访问频率相同的缓存数据；在 put 方法中，如果缓存容量已满，则会淘汰访问频率最小的缓存数据，然后添加新的缓存数据。