Java中的LRU和LFU是兩種非常有用的緩存算法，可以在緩存中存儲最近或最不常用的數(shù)據(jù)。以下是對這兩種算法的更詳細的討論。

1. LRU算法

LRU是Least Recently Used的縮寫，意思是緩存中最近最少使用的元素將被移除。實現(xiàn)LRU算法的一種方法是使用哈希表和雙向鏈表。哈希表存儲緩存中的元素，雙向鏈表用于按使用時間順序存儲元素。

以下是使用Java實現(xiàn)LRU算法的示例代碼：

public class LRUCacheextends LinkedHashMap{
private int capacity;
public LRUCache(int capacity, float loadFactor) {
super(capacity, loadFactor, true);
this.capacity = capacity;
}
protected boolean removeEldestEntry(Map.Entryeldest) {
return size() >capacity;
}
}

在上面的示例代碼中，使用了Java提供的LinkedHashMap類，該類可以按照元素的訪問順序來保存元素，并且可以設(shè)置一個固定的容量大小。當(dāng)緩存中元素數(shù)量超過容量大小時，最久未使用的元素將被刪除。

2. LFU算法

LFU是Least Frequently Used的縮寫，意思是緩存中最不常用的元素將被移除。實現(xiàn)LFU算法的一種方法是使用哈希表和最小堆。哈希表用于存儲元素的計數(shù)器，最小堆用于按照計數(shù)器大小存儲元素。

以下是使用Java實現(xiàn)LFU算法的示例代碼：

public class LFUCache{
private int capacity;
private Mapcache;
private Mapcount;
private PriorityQueueheap;
public LFUCache(int capacity) {
this.capacity = capacity;
this.cache = new HashMap<>();
this.count = new HashMap<>();
this.heap = new PriorityQueue<>(capacity, (a, b) ->count.get(a) - count.get(b));
}
public V get(K key) {
if (!cache.containsKey(key)) return null;
count.put(key, count.get(key) + 1);
heap.remove(key);
heap.offer(key);
return cache.get(key);
}
public void put(K key, V value) {
if (capacity<= 0) return;
if (cache.containsKey(key)) {
cache.put(key, value);
get(key);
return;
}
if (cache.size() >= capacity) {
K expired = heap.poll();
cache.remove(expired);
count.remove(expired);
}
cache.put(key, value);
count.put(key, 1);
heap.offer(key);
}
}

在上面的示例代碼中，使用了Java提供的PriorityQueue類，該類用于實現(xiàn)最小堆。當(dāng)緩存中元素數(shù)量超過容量大小時，被計數(shù)器值最小的元素將被刪除。