最近寫到LeetCode上的某一題LRUCache。可以採用LinkedHashMap實現，通過重寫removeEldestEntry方法，即可實現。

    LinkedHashMap map;

    public LRUCache(int capacity) {
        map = new LinkedHashMap<Integer, Integer>(capacity, 0.75f, true) {
            // 定義put後的移除規則，大於容量就刪除eldest
            protected boolean removeEldestEntry(Map.Entry<Integer, Integer> eldest) {
                return size() > capacity;
            }
        };
    }

    public int get(int key) {
        return map.containsKey(key) ? (int)map.get(key) : -1 ;
    }

    public void put(int key, int value) {
            map.put(key, value);
    }
 

1、繼承關係

1. publicclass LinkedHashMap<K,V>  
2.     extends HashMap<K,V>  
3.     implements Map<K,V>  

linkedhashmap繼承hashMap，底層的主要儲存結構是Hashmap的table。LinkedHashMap實現與HashMap的不同之處在於，後者維護著一個運行於所有條目的雙重連結列表。此連結列表定義了迭代順序，該迭代順序可以是插入順序或者是訪問順序。

2、成員變數

1. privatetransient Entry<K,V> header;
2. privatefinalboolean accessOrder;  

首先header是一個雙向連結串列，具體體現在Entry結構中，我們知道hashmap的Entry是一個單向連結串列，只有一個next屬性。

其次就是accessOrder，它決定了linkedhashmap中的元素在遍歷的時候的輸出順序（插入順序或者是訪問順序）。

3、Entry物件

static class Entry<K,V> extends HashMap.Node<K,V> {
    Entry<K
 
,V> before, after;
Entry(int hash, K key, V value, Node<K,V> next) {
        super(hash, key, value, next);
}
}

4、建構函式

1. //預設accessOrder為false
2. //呼叫HashMap建構函式
3. public LinkedHashMap() {  
4.     super();  
5.     accessOrder = false;  
6. }  
7. //如果想實現LRU演算法，參考這個建構函式
8. public LinkedHashMap(int initialCapacity, float loadFactor,  
9.         boolean accessOrder) {  
10.     super(initialCapacity, loadFactor);  
11.     this.accessOrder = accessOrder;  
12. }  
13. //模板方法模式，HashMap建構函式裡面的會呼叫init()方法
14. //初始化的時候map裡沒有任何Entry，讓header.before = header.after = header
15. void init() {  
16.     header = new Entry(-1, null, null, null);  
17.     header.before = header.after = header;  
18. }

5、儲存資料

LinkedHashMap並未重寫父類HashMap的put方法，而是重寫了父類HashMap的put方法呼叫的子方法void addEntry(int hash, K key, V value, int bucketIndex) 和void createEntry(int hash, K key, V value, int bucketIndex)，提供了自己特有的雙向連結列表的實現。

1. //LinkedHashMap沒有put(K key, V value)方法，只重寫了被put呼叫的addEntry方法
2. //1是HashMap裡原有的邏輯，23是LinkedHashMap特有的
3. void addEntry(int hash, K key, V value, int bucketIndex) {  
4.     createEntry(hash, key, value, bucketIndex);  
5.     Entry eldest = header.after;  
6.     //3.如果有必要，移除LRU裡面最老的Entry，否則判斷是否該resize
7.     if (removeEldestEntry(eldest)) {  
8.         removeEntryForKey(eldest.key);  
9.     } else {  
10.         if (size >= threshold)  
11.             resize(2 * table.length);  
12.     }  
13. }  
14. void createEntry(int hash, K key, V value, int bucketIndex) {  
15.     //1.同HashMap一樣：在Entry陣列+next連結串列結構裡面加入Entry
16.     HashMap.Entry old = table[bucketIndex];  
17.     Entry e = new Entry(hash, key, value, old);  
18.     table[bucketIndex] = e;  
19.     //2.把新Entry也加到header連結串列結構裡面去
20.     e.addBefore(header);  
21.     size++;  
22. }  
23. //預設是false，我們可以重寫此方法
24. protectedboolean removeEldestEntry(Map.Entry eldest) {  
25.     returnfalse;  
26. }  
27. privatestaticclass Entry extends HashMap.Entry {  
28.     //連結串列插入元素四個步驟，對著圖看
29.     privatevoid addBefore(Entry existingEntry) {  
30.         after = existingEntry;                //1
31.         before = existingEntry.before;     //2
32.         before.after = this;                   //3
33.         after.before = this;                   //4
34.     }  
35.        }  
36.         //如果走到resize，會呼叫這裡重寫的transfer
37. //HashMap裡面的transfer是n * m次運算，LinkedHashtable重寫後是n + m次運算
38. void transfer(HashMap.Entry[] newTable) {  
39.     int newCapacity = newTable.length;  
40.     //直接遍歷header連結串列，HashMap裡面是遍歷Entry陣列
41.     for (Entry e = header.after; e != header; e = e.after) {  
42.         int index = indexFor(e.hash, newCapacity);  
43.         e.next = newTable[index];  
44.         newTable[index] = e;  
45.     }  
46.  }  

LinkedHashMap重寫了父類HashMap的get方法，實際在呼叫父類getEntry()方法取得查詢的元素後，再判斷當排序模式accessOrder為true時，記錄訪問順序，將最新訪問的元素新增到雙向連結串列的表頭，並從原來的位置刪除。由於的連結串列的增加、刪除操作是常量級的，故並不會帶來效能的損失。

1. //重寫了get(Object key)方法
2. public V get(Object key) {  
3.     //1.呼叫HashMap的getEntry方法得到e
4.     Entry e = (Entry) getEntry(key);  
5.     if (e == null)  
6.         returnnull;  
7.     //2.LinkedHashMap牛B的地方
8.     e.recordAccess(this);  
9.     return e.value;  
10. }  
11.        // 繼承了HashMap.Entry
12. privatestaticclass Entry extends HashMap.Entry {  
13.     //1.此方法提供了LRU的實現
14.     //2.通過12兩步，把最近使用的當前Entry移到header的before位置，而LinkedHashIterator遍歷的方式是從header.after開始遍歷，先得到最近使用的Entry
15.     //3.最近使用是什麼意思：accessOrder為true時，get(Object key)方法會導致Entry最近使用；put(K key, V value)/putForNullKey(value)只有是覆蓋操作時會導致Entry最近使用。它們都會觸發recordAccess方法從而導致Entry最近使用
16.     //4.總結LinkedHashMap迭代方式：accessOrder=false時，迭代出的資料按插入順序；accessOrder=true時，迭代出的資料按LRU順序+插入順序
17.     //  HashMap迭代方式：橫向陣列 * 豎向next連結串列
18.     void recordAccess(HashMap m) {  
19.         LinkedHashMap lm = (LinkedHashMap) m;  
20.         //如果使用LRU演算法
21.         if (lm.accessOrder) {  
22.             lm.modCount++;  
23.             //1.從header連結串列裡面移除當前Entry
24.             remove();  
25.             //2.把當前Entry移到header的before位置
26.             addBefore(lm.header);  
27.         }  
28.     }  
29.     //讓當前Entry從header連結串列消失
30.     privatevoid remove() {  
31.         before.after = after;  
32.         after.before = before;  
33.     }  
34.        }  

7、刪除資料

1. // 繼承了HashMap.Entry
2. privatestaticclass Entry extends HashMap.Entry {  
3.     //LinkedHashMap沒有重寫remove(Object key)方法，重寫了被remove呼叫的recordRemoval方法
4.     //這個方法的設計也和精髓，也是模板方法模式
5.     //HahsMap remove(Object key)把資料從橫向陣列 * 豎向next連結串列裡面移除之後（就已經完成工作了，所以HashMap裡面recordRemoval是空的實現呼叫了此方法
6.     //但在LinkedHashMap裡面，還需要移除header連結串列裡面Entry的after和before關係
7.     void recordRemoval(HashMap m) {  
8.         remove();  
9.     }  
10.     //讓當前Entry從header連結串列消失
11.     privatevoid remove() {  
12.         before.after = after;  
13.         after.before = before;  
14.     }  
15. }  

1. privateabstractclass LinkedHashIterator implements Iterator {  
2.     //從header.after開始遍歷
3.     Entry nextEntry = header.after;  
4.     Entry nextEntry() {  
5.         if (modCount != expectedModCount)  
6.             thrownew ConcurrentModificationException();  
7.         if (nextEntry == header)  
8.             thrownew NoSuchElementException();  
9.         Entry e = lastReturned = nextEntry;  
10.         nextEntry = e.after;  
11.         return e;  
12.     }  
13. }  

九.總結

1. LinkedHashMap繼承HashMap，結構2裡資料結構的變化交給HashMap就行了。
2. 結構1裡資料結構的變化就由LinkedHashMap裡重寫的方法去實現。
3. 簡言之：LinkedHashMap比HashMap多維護了一個連結串列。