算法-LRU

利用双向链表实现LRU算法

package lru;

import java.util.HashMap;
/**
 * 模拟redis淘汰策略
 * @author mac
 * @param <K>
 * @param <V>
 */
public class LRU<K,V> {
	LRU(int size){
		this.capacity = size;
		cache = new HashMap<K,Node<K,V>>(size);
	}
	private int capacity; 
	private HashMap<K,Node<K,V>> cache;
	private Node<K,V> first;
	private Node<K,V> last;
	/**
	 * 维护一个双向链表来模拟淘汰策略。
	 * 放入的元素直接调整到链表头部
	 * @param key
	 * @param value
	 */
	public void put(K key ,V value) {
		Node<K,V> node = cache.get(key);
		if(node == null) {
			if(cache.size() >= capacity) {
				cache.remove(key);
				removeLast();
			}
			node = new Node<K,V>(key,value);
		}
		node.value = value;
		cache.put(key, node);
		moveToHead(node);
	}
	/**
	 * 查询元素时，将查询到的元素调整到链表头部
	 * @param key
	 * @return
	 */
	public Object get(K key) {
		Node<K,V> node = cache.get(key);
		if(node == null) {
			return null;
		}
		moveToHead(node);
		return node.value;
	}
	/**
	 * 删除元素直接删除，调整其他链表节点
	 * @param key
	 * @return
	 */
	public Object remove(K key) {
		Node<K, V> node = cache.get(key);
		if(node != null) {
			if(node.prev != null) {
				node.prev.next = node.next;
			}
			if(node.next != null) {
				node.next.prev = node.prev;
			}
			if(node == first) {
				first = first.next;
			}
			if(node == last) {
				last = last.prev;
			}
		}
		return cache.remove(key);
	}
	/**
	 * 删除链表的最后一个节点
	 */
	private void removeLast() {
		if(last != null) {
			last = last.prev;
			if(last == null) {
				first = null;
			}else {
				last.next = null;
			}
		}
	}
	/**
	 * 移动到队列头
	 * @param node
	 */
	private void moveToHead(Node<K,V> node) {
		if(first == node) {
			return;
		}
		if(node.prev != null) {
			node.prev.next = node.next;
		}
		if(node.next != null) {
			node.next.prev = node.prev;
		}
		if(last == node) {
			last = last.prev;
			if(last != null ){
        		last.next = null;
			}
		}
		if(first == null || last == null) {
			first = last = node;
			return;
		}
		node.next = first;
		first.prev = node;
		first = node;
		first.prev = null;
	}
	public String toString() {
		Node node = first;
		StringBuffer sb = new StringBuffer();
		while(node != null) {
			sb.append(node.value);
			node = node.next;
		}
		return sb.toString();
	}
	final class Node<K,V> {
		Node<K,V> prev;
		Node<K,V> next;
		K key;
		V value;
		Node(K key ,V value){
			this.key = key;
			this.value = value;
		}
	}
}