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");

}

}

}