1 import java.util.LinkedHashMap;
 2 import java.util.Collection;
 3 import java.util.Map;
 4 import java.util.ArrayList;
 5
 6 /**
 7 * An LRU cache, based on <code>LinkedHashMap</code>.
 8 *
 9 * <p>
10 * This cache has a fixed maximum number of elements (<code>cacheSize</code>).
11 * If the cache is full and another entry is added, the LRU (least recently used) entry is dropped.
12 *
13 * <p>
14 * This class is thread-safe. All methods of this class are synchronized.
15 *
16 * <p>
17 * Author: Christian d'Heureuse, Inventec Informatik AG, Zurich, Switzerland<br>
18 * Multi-licensed: EPL / LGPL / GPL / AL / BSD.
19 */
20 public class LRUCache<K,V> {
21
22 private static final float   hashTableLoadFactor = 0.75f;
23
24 private LinkedHashMap<K,V>   map;
25 private int                  cacheSize;
26
27 /**
28 * Creates a new LRU cache.
29 * @param cacheSize the maximum number of entries that will be kept in this cache.
30 */
31 public LRUCache (int cacheSize) {
32    this.cacheSize = cacheSize;
33    int hashTableCapacity = (int)Math.ceil(cacheSize / hashTableLoadFactor) + 1;
34    map = new LinkedHashMap<K,V>(hashTableCapacity, hashTableLoadFactor, true) {
35       // (an anonymous inner class)
36       private static final long serialVersionUID = 1;
37       @Override protected boolean removeEldestEntry (Map.Entry<K,V> eldest) {
38          return size() > LRUCache.this.cacheSize; }}; }
39
40 /**
41 * Retrieves an entry from the cache.<br>
42 * The retrieved entry becomes the MRU (most recently used) entry.
43 * @param key the key whose associated value is to be returned.
44 * @return    the value associated to this key, or null if no value with this key exists in the cache.
45 */
46 public synchronized V get (K key) {
47    return map.get(key); }
48
49 /**
50 * Adds an entry to this cache.
51 * The new entry becomes the MRU (most recently used) entry.
52 * If an entry with the specified key already exists in the cache, it is replaced by the new entry.
53 * If the cache is full, the LRU (least recently used) entry is removed from the cache.
54 * @param key    the key with which the specified value is to be associated.
55 * @param value  a value to be associated with the specified key.
56 */
57 public synchronized void put (K key, V value) {
58    map.put (key, value); }
59
60 /**
61 * Clears the cache.
62 */
63 public synchronized void clear() {
64    map.clear(); }
65
66 /**
67 * Returns the number of used entries in the cache.
68 * @return the number of entries currently in the cache.
69 */
70 public synchronized int usedEntries() {
71    return map.size(); }
72
73 /**
74 * Returns a <code>Collection</code> that contains a copy of all cache entries.
75 * @return a <code>Collection</code> with a copy of the cache content.
76 */
77 public synchronized Collection<Map.Entry<K,V>> getAll() {
78    return new ArrayList<Map.Entry<K,V>>(map.entrySet()); }
79
80 } // end class LRUCache
81 ------------------------------------------------------------------------------------------
82 // Test routine for the LRUCache class.
83 public static void main (String[] args) {
84    LRUCache<String,String> c = new LRUCache<String, String>(3);
85    c.put ("1", "one");                           // 1
86    c.put ("2", "two");                           // 2 1
87    c.put ("3", "three");                         // 3 2 1
88    c.put ("4", "four");                          // 4 3 2
89    if (c.get("2") == null) throw new Error();    // 2 4 3
90    c.put ("5", "five");                          // 5 2 4
91    c.put ("4", "second four");                   // 4 5 2
92    // Verify cache content.
93    if (c.usedEntries() != 3)              throw new Error();
94    if (!c.get("4").equals("second four")) throw new Error();
95    if (!c.get("5").equals("five"))        throw new Error();
96    if (!c.get("2").equals("two"))         throw new Error();
97    // List cache content.
98    for (Map.Entry<String, String> e : c.getAll())
99       System.out.println (e.getKey() + " : " + e.getValue()); }  

  1 public class LRUCache {
  2
  3     private int cacheSize;
  4     private Hashtable<Object, Entry> nodes;//缓存容器
  5     private int currentSize;
  6     private Entry first;//链表头
  7     private Entry last;//链表尾
  8
  9     public LRUCache(int i) {
 10         currentSize = 0;
 11         cacheSize = i;
 12         nodes = new Hashtable<Object, Entry>(i);//缓存容器
 13     }
 14
 15     /**
 16      * 获取缓存中对象,并把它放在最前面
 17      */
 18     public Entry get(Object key) {
 19         Entry node = nodes.get(key);
 20         if (node != null) {
 21             moveToHead(node);
 22             return node;
 23         } else {
 24             return null;
 25         }
 26     }
 27
 28     /**
 29      * 添加 entry到hashtable, 并把entry
 30      */
 31     public void put(Object key, Object value) {
 32         //先查看hashtable是否存在该entry, 如果存在，则只更新其value
 33         Entry node = nodes.get(key);
 34
 35         if (node == null) {
 36             //缓存容器是否已经超过大小.
 37             if (currentSize >= cacheSize) {
 38                 nodes.remove(last.key);
 39                 removeLast();
 40             } else {
 41                 currentSize++;
 42             }
 43             node = new Entry();
 44         }
 45         node.value = value;
 46         //将最新使用的节点放到链表头，表示最新使用的.
 47         moveToHead(node);
 48         nodes.put(key, node);
 49     }
 50
 51     /**
 52      * 将entry删除, 注意：删除操作只有在cache满了才会被执行
 53      */
 54     public void remove(Object key) {
 55         Entry node = nodes.get(key);
 56         //在链表中删除
 57         if (node != null) {
 58             if (node.prev != null) {
 59                 node.prev.next = node.next;
 60             }
 61             if (node.next != null) {
 62                 node.next.prev = node.prev;
 63             }
 64             if (last == node)
 65                 last = node.prev;
 66             if (first == node)
 67                 first = node.next;
 68         }
 69         //在hashtable中删除
 70         nodes.remove(key);
 71     }
 72
 73     /**
 74      * 删除链表尾部节点，即使用最后 使用的entry
 75      */
 76     private void removeLast() {
 77         //链表尾不为空,则将链表尾指向null. 删除连表尾（删除最少使用的缓存对象）
 78         if (last != null) {
 79             if (last.prev != null)
 80                 last.prev.next = null;
 81             else
 82                 first = null;
 83             last = last.prev;
 84         }
 85     }
 86
 87     /**
 88      * 移动到链表头，表示这个节点是最新使用过的
 89      */
 90     private void moveToHead(Entry node) {
 91         if (node == first)
 92             return;
 93         if (node.prev != null)
 94             node.prev.next = node.next;
 95         if (node.next != null)
 96             node.next.prev = node.prev;
 97         if (last == node)
 98             last = node.prev;
 99         if (first != null) {
100             node.next = first;
101             first.prev = node;
102         }
103         first = node;
104         node.prev = null;
105         if (last == null)
106             last = first;
107     }
108     /*
109      * 清空缓存
110      */
111     public void clear() {
112         first = null;
113         last = null;
114         currentSize = 0;
115     }
116
117 }
118
119 class Entry {
120     Entry prev;//前一节点
121     Entry next;//后一节点
122     Object value;//值
123     Object key;//键
124 }