1 package com.simple.test;
  2 
  3 import java.util.ArrayList;
  4 import java.util.HashMap;
  5 import java.util.List;
  6 
  7 public class SimpleLRUCache <K,V>{
  8     int maxSize;            // 最大容量
  9     Entry<K,V> head;        // 头节点
 10     Entry<K,V> tail;        // 尾节点
 11     HashMap<K,V> hashMap;   // 哈希表
 12     // 构造函数
 13     public SimpleLRUCache(int size) {
 14         if (size <= 0)
 15             throw new RuntimeException("容器大小不能<=0");
 16         this.maxSize = size;
 17         this.hashMap = new HashMap<>();
 18     }
 19     static class Entry<K,V> {
 20         final int hash;     // 哈希值
 21         final K key;        // 键
 22         V value;            // 值
 23         Entry<K,V> before;  // 先继节点
 24         Entry<K,V> after;   // 后继节点
 25         Entry(int hash, K key, V value, Entry before, Entry after) {
 26             this.hash = hash;
 27             this.key = key;
 28             this.value = value;
 29             this.before = before;
 30             this.after = after;
 31         }
 32     }
 33     // 查询元素
 34     public V get(Object key) {
 35         V res = hashMap.get(key);
 36         // 如果在已有数据中找到，则将该元素放置到队首
 37         if (res != null)
 38             moveToFront(key);
 39         return res;
 40     }
 41     // 存入元素/修改元素
 42     public void put(K key, V value) {
 43         V res = hashMap.put(key,value);
 44         // 如果res为null，表示没找到，则存入并放置到队首
 45         if (res == null) {
 46             Entry<K,V> entry = new Entry<>(key.hashCode(), key, value, null, head);
 47             // 如果之前没有头节点
 48             if (head == null) {
 49                 head = entry;
 50                 tail = entry;
 51             } else {
 52                 // 如果之前有头节点，将头节点before指向entry
 53                 entry.after = head;
 54                 head.before = entry;
 55                 head = entry;
 56             }
 57             // 判断此时节点数量是否超过最大容量,如果超过，则将队尾元素删除
 58             if (hashMap.size() > maxSize) {
 59                 tail = tail.before;
 60                 tail.after = null;
 61             }
 62         } else {
 63             // 如果res不为null,表示包含该元素，则将节点放置到队首
 64             Entry<K,V> entry = moveToFront(key);
 65             // 同时修改节点的V值
 66             entry.value = value;
 67         }
 68     }
 69     // 删除元素
 70     public void remove(Object key) {
 71         V res = hashMap.remove(key);
 72         // 如果删除成功，则将链表中节点一并删除
 73         if (res != null)
 74             removeFromLinkedList(key);
 75     }
 76     // 将key对应的元素移至队首
 77     Entry<K,V> moveToFront(Object key) {
 78         // 遍历链表找到该元素
 79         Entry<K,V> entry = find(key);
 80         // 如果找到了并且不是队首,则将该节点移动到队列的首部
 81         if (entry != null && entry != head) {
 82             // 如果该节点是队尾
 83             if (entry == tail)
 84                 tail = entry.before;
 85             // 先将该节点从链表中移出
 86             Entry<K,V> p = entry.before;
 87             Entry<K,V> q = entry.after;
 88             p.after = q;
 89             if (q != null)
 90                 q.before = p;
 91             // 然后将该节点作为新的head
 92             entry.before = null;
 93             entry.after = head;
 94             head = entry;
 95         }
 96         return entry;
 97     }
 98     // 将key对应的元素从双端链表中删除
 99     void removeFromLinkedList(Object key) {
100         // 遍历链表找到该元素
101         Entry<K,V> entry = find(key);
102         // 如果没找到则直接返回
103         if (entry == null)  return;
104         // 如果是队首元素
105         if (entry == head) {
106             // 只有一个节点
107             if (tail == head)
108                 tail = entry.after;
109             head = entry.after;
110             head.before = null;
111         } else if (entry == tail) {
112             // 如果是队尾元素
113             tail = tail.before;
114             tail.after = null;
115         }
116     }
117     // 根据key从链表中找对应节点
118     Entry<K, V> find(Object key) {
119         // 遍历链表找到该元素
120         Entry<K,V> entry = head;
121         while (entry != null) {
122             if (entry.key.equals(key))
123                 break;
124             entry = entry.after;
125         }
126         return entry;
127     }
128     // 顺序返回元素
129     public List<Entry<K,V>> getList() {
130         List<Entry<K,V>> list = new ArrayList<>();
131         Entry<K,V> p = head;
132         while (p != null) {
133             list.add(p);
134             p = p.after;
135         }
136         return list;
137     }
138     // 顺序输出元素
139     public void print() {
140         Entry<K,V> p = head;
141         while (p != null) {
142             System.out.print(p.key.toString()+":"+p.value.toString()+"\t");
143             p = p.after;
144         }
145         System.out.println();
146     }
147     public static void main(String[] args) {
148         SimpleLRUCache<String, String> test = new SimpleLRUCache(4);
149         test.put("a","1");
150         test.put("b","2");
151         test.put("c","3");
152         test.put("d","4");
153         // 此时顺序为d c b a
154         test.print();
155         // 获取a,此时顺序为 a d c b
156         test.get("a");
157         test.print();
158         // 修改c，此时顺序为 c a d b
159         test.put("c","31");
160         test.print();
161         // 增加e,淘汰末尾元素b,此时顺序为e c a d
162         test.put("e","5");
163         test.print();
164     }
165 }