cache 清除算法 LRU & LFU & FIFO

LRU:

LinkedHashMap ,

实现思路：HashMap　＋　双向链表环

按照最近访问/插入顺序，始终保持队列尾部的为最近访问或者最近插入的数据，删除从对头开始！

LinkedHashMap扩展如下方法即可：

 

protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
        return false;
    }

 

 

LFU：

实现思路：HashMap　＋　PriorityQueue

下面是个根据Key的自然数据排序的案例（类似，可以把Key包装成一个可排序的包装类型，根据访问次数确定顺序）：

 

import java.util.HashMap;
import java.util.PriorityQueue;

/**
 * 
 * @author xinchun.wang
 * @email: [e-mail]
 */
public class LFUHashMap<K, V> {

	private static final int max_size = 10;

	HashMap<K, V> map = new HashMap<K, V>();

	PriorityQueue<Node<K>> tSet = new PriorityQueue<Node<K>>();

	@SuppressWarnings("unchecked")
	public V put(K key, V value) {
		if (map.size() > max_size) {
			Node<K> firstKey = (Node<K>) tSet.poll();
			map.remove(firstKey.getKey());
		}
		tSet.add(new Node(key, 1));
		return map.put(key, value);
	}

	public V get(Object key) {
		V result = map.get(key);
		incHit(key);
		return result;
	}

	private void incHit(Object key) {
		for (Object item : tSet) {
			if (((Node) item).key == key) {
				((Node) item).setCount(((Node) item).getCount() + 1);
				break;
			}
		}
	}

	@Override
	public String toString() {
		return map.toString();
	}

	public static void main(String[] args) {
		LFUHashMap<Integer, String> lfu = new LFUHashMap<Integer, String>();
		for (int i = 0; i < 100; i++) {
			lfu.put(i, String.valueOf(i) + "_data");
			if (i > 5) {
				lfu.get(1);
				lfu.get(2);
				lfu.get(3);
				lfu.get(4);
			}
			if (i > 10) {
				lfu.get(9);
			}
		}
		while (lfu.tSet.peek() != null) {
			System.out.println(lfu.tSet.poll());
		}
		System.out.println(lfu);
	}

	private static class Node<K> implements Comparable<Node<K>> {
		private K key;
		private int count;

		public Node(K key, int count) {
			this.key = key;
			this.count = count;
		}

		public K getKey() {
			return key;
		}

		public int getCount() {
			return count;
		}

		public void setCount(int count) {
			this.count = count;
		}

		@Override
		public String toString() {
			return "Node [key=" + key + ", count=" + count + "]";
		}

		@Override
		public int compareTo(Node<K> o) {
			int diff = this.count - o.count;
			return diff != 0 ? diff : -((Integer) o.key).compareTo((Integer) this.key);
		}

	}

}

 

 

FIFO:

仿照LinkedHashMap，通过LinkedList 就可以实现FIFO的元素排队