LRU缓存的java实现

LRU缓存：

LRU缓存利用了这样的一种思想。LRU是Least Recently Used 的缩写，翻译过来就是“最近最少使用”，也就是说，LRU缓存把最近最少使用的数据移除，让给最新读取的数据。而往往最常读取的，也是读取次数最多的，所以，利用LRU缓存，我们能够提高系统的performance

下面的LRU是：双向链表结合hashtable进行实现

package lruCache;

import java.util.ArrayList;
import java.util.Hashtable;
import java.util.LinkedList;
public class LruCachefjsh {
  private int cacheSize;  
   private Hashtable nodes;//缓存容器  
   private int currentSize;  
   private CacheNode first;//链表头  
   private CacheNode last;//链表尾  
/** 
     * 链表节点 
     * @author Administrator 
     * 
     */  
    class CacheNode {  
        CacheNode prev;//前一节点  
        CacheNode next;//后一节点  
        Object value;//值  
        Object key;//键  
        CacheNode() {  
        }  
    }  
    public LruCachefjsh(int i) {  
        currentSize = 0;  
        cacheSize = i;  
        nodes = new Hashtable(i);//缓存容器  
    }  
    /** 
     * 获取缓存中对象 
     * @param key 
     * @return 
     */  
    public synchronized Object get(Object key) {  
        CacheNode node = (CacheNode) nodes.get(key);  
        if (node != null) {  
            moveToHead(node);  
            return node.value;  
        } else {  
            return null;  
        }  
    }  
    /** 
     * 移动到链表头，表示这个节点是最新使用过的 
     * @param node 
     */  
    private void moveToHead(CacheNode node) {  
        if (node == first)  
            return;  
        if (node.prev != null)  
            node.prev.next = node.next;  
        if (node.next != null)  
            node.next.prev = node.prev;  
        if (last == node)  
            last = node.prev;  
        if (first != null) {  
            node.next = first;  
            first.prev = node;  
        }  
        first = node;  
        node.prev = null;  
        if (last == null)  
            last = first;  
    } 
    /** 
     * 添加缓存 
     * @param key 
     * @param value 
     */  
    public synchronized void put(Object key, Object value) {  
        CacheNode node = (CacheNode) nodes.get(key);  
          
        if (node == null) {  
            //缓存容器是否已经超过大小.  
            if (currentSize >= cacheSize) {  
                if (last != null)//将最少使用的删除  
                    nodes.remove(last.key);  
                removeLast();  
            } else {  
                currentSize++;  
            }  
              
            node = new CacheNode();  
        }  
        node.value = value;  
        node.key = key;  
        //将最新使用的节点放到链表头，表示最新使用的.  
        moveToHead(node);  
        nodes.put(key, node);  
    }  
    /** 
     * 删除链表尾部节点 
     *  表示 删除最少使用的缓存对象 
     */  
    private void removeLast() {  
        //链表尾不为空,则将链表尾指向null. 删除连表尾（删除最少使用的缓存对象）  
        if (last != null) {  
            if (last.prev != null)  
                last.prev.next = null;  
            else  
                first = null;  
            last = last.prev;  
        }  
    }  
    /** 
     * 将缓存删除 
     * 删除操作只有在cache满了才会被执行 
     * @param key 
     * @return 
     */  
    public Object remove(Object key) {  
        CacheNode node = (CacheNode) nodes.get(key); 
        //在链表中删除  
        if (node != null) {  
            if (node.prev != null) {  
                node.prev.next = node.next;  
            }  
            if (node.next != null) {  
                node.next.prev = node.prev;  
            }  
            if (last == node)  
                last = node.prev;  
            if (first == node)  
                first = node.next;  
        }  
       /* //在hashtable中删除  一般这里不用
        nodes.remove(key);  */
        return node;  
    }  
  
    public void clear() {  
        first = null;  
        last = null;  
    }  
public static void main(String[] args) {

LruCachefjsh lcf=new LruCachefjsh(4);
lcf.put("1", "1");
lcf.put("2", "2");
lcf.put("3", "3");
lcf.put("4", "4");
if(lcf.get("4")!=null)
{
System.out.println("第一个为："+lcf.first.value);
}
else
{
System.out.println("没有找到4");
}
lcf.put("5", "5");
if(lcf.get("1")!=null)
{
System.out.println("第一个为："+lcf.first.value);
}
else
{
System.out.println("没有找到1");
}
if(lcf.get("2")!=null)
{
System.out.println("第一个为："+lcf.first.value);
}
else
{
System.out.println("没有找到2");
}
}
}