public class LRUByHashMap<K, V> {
 /*
 * 通過LinkHashMap簡單實現LRU算法
 */
 /**
 * 緩存大小
 */
 private int cacheSize;
 /**
 * 當前緩存數目
 */
 private int currentSize;
 private LinkedHashMap<K, V> maps;
 public LRUByHashMap(int cacheSize1) {
 this.cacheSize = cacheSize1;
 maps = new LinkedHashMap<K, V>() {
  /**
  *
  */
  private static final long serialVersionUID = 1;
  // 這里移除舊的緩存數據
  @Override
  protected boolean removeEldestEntry(java.util.Map.Entry<K, V> eldest) {
  // 當超過緩存數量的時候就將舊的數據移除
  return getCurrentSize() > LRUByHashMap.this.cacheSize;
  }
 };
 }
 public synchronized int getCurrentSize() {
 return maps.size();
 }
 public synchronized void put(K k, V v) {
 if (k == null) {
  throw new Error("存入的鍵值不能為空");
 }
 maps.put(k, v);
 }
 public synchronized void remove(K k) {
 if (k == null) {
  throw new Error("移除的鍵值不能為空");
 }
 maps.remove(k);
 }
 public synchronized void clear() {
 maps = null;
 }
 // 獲取集合
 public synchronized Collection<V> getCollection() {
 if (maps != null) {
  return maps.values();
 } else {
  return null;
 }
 }
 public static void main(String[] args) {
 // 測試
 LRUByHashMap<Integer, String> maps = new LRUByHashMap<Integer, String>(
  3);
 maps.put(1, "1");
 maps.put(2, "2");
 maps.put(3, "3");
 maps.put(4, "4");
 maps.put(5, "5");
 maps.put(6, "6");
 Collection<String> col = maps.getCollection();
 System.out.println("存入緩存中的數據是--->>" + col.toString());
 }
}

public class LRUCache {
 private int cacheSize;
 private Hashtable<Object, Entry> nodes;//緩存容器
 private int currentSize;
 private Entry first;//鏈表頭
 private Entry last;//鏈表尾
 public LRUCache(int i) {
 currentSize = 0;
 cacheSize = i;
 nodes = new Hashtable<Object, Entry>(i);//緩存容器
 }
 /**
 * 獲取緩存中對象,并把它放在最前面
 */
 public Entry get(Object key) {
 Entry node = nodes.get(key);
 if (node != null) {
  moveToHead(node);
  return node;
 } else {
  return null;
 }
 }
 /**
 * 添加 entry到hashtable, 并把entry 
 */
 public void put(Object key, Object value) {
 //先查看hashtable是否存在該entry, 如果存在，則只更新其value
 Entry node = nodes.get(key);
 if (node == null) {
  //緩存容器是否已經超過大小.
  if (currentSize >= cacheSize) {
  nodes.remove(last.key);
  removeLast();
  } else {
  currentSize++;
  }  
  node = new Entry();
 }
 node.value = value;
 //將最新使用的節點放到鏈表頭，表示最新使用的.
 node.key = key
 moveToHead(node);
 nodes.put(key, node);
 }
 /**
 * 將entry刪除, 注意：刪除操作只有在cache滿了才會被執行
 */
 public void remove(Object key) {
 Entry node = 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);
 }
 /**
 * 刪除鏈表尾部節點，即使用最后 使用的entry
 */
 private void removeLast() {
 //鏈表尾不為空,則將鏈表尾指向null. 刪除連表尾（刪除最少使用的緩存對象）
 if (last != null) {
  if (last.prev != null)
  last.prev.next = null;
  else
  first = null;
  last = last.prev;
 }
 }
 /**
 * 移動到鏈表頭，表示這個節點是最新使用過的
 */
 private void moveToHead(Entry 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;
 }
 /*
 * 清空緩存
 */
 public void clear() {
 first = null;
 last = null;
 currentSize = 0;
 }
}
class Entry {
 Entry prev;//前一節點
 Entry next;//后一節點
 Object value;//值
 Object key;//鍵
}