1.HashMap沒啥可說的

2.LinkedHashMap是HashMap的子類，在HashMap的基礎上加了一個連結串列，每次put元素都會往連結串列上加節點。

public LinkedHashMap(int initialCapacity, float loadFactor,boolean accessOrder)：   accessOrder為true的時候按照元素最後訪問時間排序（LRU演算法：最近最久使用），為false則是按照插入順序排序，預設為false.

LinkedHashMap 的get和put方法對HashMap加了些改動，會調整LinkedHashMap的連結串列結構。

以下摘自http://blog.csdn.net/ns_code/article/details/37867985

 關於LinkedHashMap的原始碼，給出以下幾點比較重要的總結：

    1、從原始碼中可以看出，LinkedHashMap中加入了一個head頭結點，將所有插入到該LinkedHashMap中的Entry按照插入的先後順序依次加入到以head為頭結點的雙向迴圈連結串列的尾部。

    實際上就是HashMap和LinkedList兩個集合類的儲存結構的結合。在LinkedHashMapMap中，所有put進來的Entry都儲存在如第一個圖所示的雜湊表中，但它又額外定義了一個以head為頭結點的空的雙向迴圈連結串列

，每次put進來Entry，除了將其儲存到對雜湊表中對應的位置上外，還要將其插入到雙向迴圈連結串列的尾部。

    2、LinkedHashMap由於繼承自HashMap，因此它具有HashMap的所有特性，同樣允許key和value為null。

    3、注意原始碼中的accessOrder標誌位，當它false時，表示雙向連結串列中的元素按照Entry插入LinkedHashMap到中的先後順序排序，即每次put到LinkedHashMap中的Entry都放在雙向連結串列的尾部，這樣遍歷雙向連結串列時，Entry的輸出順序便和插入的順序一致，這也是預設的雙向連結串列的儲存順序；當它為true時，表示雙向連結串列中的元素按照訪問的先後順序排列

，可以看到，雖然Entry插入連結串列的順序依然是按照其put到LinkedHashMap中的順序，但put和get方法均有呼叫recordAccess方法（put方法在key相同，覆蓋原有的Entry的情況下呼叫recordAccess方法），該方法判斷accessOrder是否為true，如果是，則將當前訪問的Entry（put進來的Entry或get出來的Entry）移到雙向連結串列的尾部（key不相同時，put新Entry時，會呼叫addEntry，它會呼叫creatEntry，該方法同樣將新插入的元素放入到雙向連結串列的尾部，既符合插入的先後順序，又符合訪問的先後順序，因為這時該Entry也被訪問了），否則，什麼也不做。

    4、注意構造方法，前四個構造方法都將accessOrder設為false，說明預設是按照插入順序排序的，而第五個構造方法可以自定義傳入的accessOrder的值，因此可以指定雙向迴圈連結串列中元素的排序規則，一般要用LinkedHashMap實現LRU演算法，就要用該構造方法，將accessOrder置為true。

    5、LinkedHashMap並沒有覆寫HashMap中的put方法，而是覆寫了put方法中呼叫的addEntry方法和recordAccess方法，我們回過頭來再看下HashMap的put方法：

1. // 將“key-value”新增到HashMap中    
2. public V put(K key, V value) {      
3.     // 若“key為null”，則將該鍵值對新增到table[0]中。    
4.     if (key == null)      
5.         return putForNullKey(value);      
6.     // 若“key不為null”，則計算該key的雜湊值，然後將其新增到該雜湊值對應的連結串列中。    
7.     int hash = hash(key.hashCode());      
8.     int i = indexFor(hash, table.length);      
9.     for (Entry<K,V> e = table[i]; e != null; e = e.next) {      
10.         Object k;      
11.         // 若“該key”對應的鍵值對已經存在，則用新的value取代舊的value。然後退出！    
12.         if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {      
13.             V oldValue = e.value;      
14.             e.value = value;      
15.             e.recordAccess(this);      
16.             return oldValue;      
17.         }      
18.     }      
19.     // 若“該key”對應的鍵值對不存在，則將“key-value”新增到table中    
20.     modCount++;    
21.     //將key-value新增到table[i]處  
22.     addEntry(hash, key, value, i);      
23.     returnnull;      
24. }      

    當要put進來的Entry的key在雜湊表中已經在存在時，會呼叫recordAccess方法，當該key不存在時，則會呼叫addEntry方法將新的Entry插入到對應槽的單鏈表的頭部。

    我們先來看recordAccess方法：

1. //覆寫HashMap中的recordAccess方法（HashMap中該方法為空），
2. //當呼叫父類的put方法，在發現插入的key已經存在時，會呼叫該方法，
3. //呼叫LinkedHashmap覆寫的get方法時，也會呼叫到該方法，
4. //該方法提供了LRU演算法的實現，它將最近使用的Entry放到雙向迴圈連結串列的尾部，
5. //accessOrder為true時，get方法會呼叫recordAccess方法
6. //put方法在覆蓋key-value對時也會呼叫recordAccess方法
7. //它們導致Entry最近使用，因此將其移到雙向連結串列的末尾
8.       void recordAccess(HashMap<K,V> m) {  
9.           LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;  
10.     //如果連結串列中元素按照訪問順序排序，則將當前訪問的Entry移到雙向迴圈連結串列的尾部，
11.     //如果是按照插入的先後順序排序，則不做任何事情。
12.           if (lm.accessOrder) {  
13.               lm.modCount++;  
14.         //移除當前訪問的Entry
15.               remove();  
16.         //將當前訪問的Entry插入到連結串列的尾部
17.               addBefore(lm.header);  
18.           }  
19.       }  

    該方法會判斷accessOrder是否為true，如果為true，它會將當前訪問的Entry（在這裡指put進來的Entry）移動到雙向迴圈連結串列的尾部，從而實現雙向連結串列中的元素按照訪問順序來排序（最近訪問的Entry放到連結串列的最後，這樣多次下來，前面就是最近沒有被訪問的元素，在實現、LRU演算法時，當雙向連結串列中的節點數達到最大值時，將前面的元素刪去即可，因為前面的元素是最近最少使用的），否則什麼也不做。
    再來看addEntry方法：

1. //覆寫HashMap中的addEntry方法，LinkedHashmap並沒有覆寫HashMap中的put方法，
2. //而是覆寫了put方法所呼叫的addEntry方法和recordAccess方法，
3. //put方法在插入的key已存在的情況下，會呼叫recordAccess方法，
4. //在插入的key不存在的情況下，要呼叫addEntry插入新的Entry
5.    void addEntry(int hash, K key, V value, int bucketIndex) {  
6.     //建立新的Entry，並插入到LinkedHashMap中
7.        createEntry(hash, key, value, bucketIndex);  
8.        //雙向連結串列的第一個有效節點（header後的那個節點）為近期最少使用的節點
9.        Entry<K,V> eldest = header.after;  
10.     //如果有必要，則刪除掉該近期最少使用的節點，
11.     //這要看對removeEldestEntry的覆寫,由於預設為false，因此預設是不做任何處理的。
12.        if (removeEldestEntry(eldest)) {  
13.            removeEntryForKey(eldest.key);  
14.        } else {  
15.         //擴容到原來的2倍
16.            if (size >= threshold)  
17.                resize(2 * table.length);  
18.        }  
19.    }  
20.    void createEntry(int hash, K key, V value, int bucketIndex) {  
21.     //建立新的Entry，並將其插入到陣列對應槽的單鏈表的頭結點處，這點與HashMap中相同
22.        HashMap.Entry<K,V> old = table[bucketIndex];  
23.     Entry<K,V> e = new Entry<K,V>(hash, key, value, old);  
24.        table[bucketIndex] = e;  
25.     //每次插入Entry時，都將其移到雙向連結串列的尾部，
26.     //這便會按照Entry插入LinkedHashMap的先後順序來迭代元素，
27.     //同時，新put進來的Entry是最近訪問的Entry，把其放在連結串列末尾 ，符合LRU演算法的實現
28.        e.addBefore(header);  
29.        size++;  
30.    }  

    同樣是將新的Entry插入到table中對應槽所對應單鏈表的頭結點中，但可以看出，在createEntry中，同樣把新put進來的Entry插入到了雙向連結串列的尾部，從插入順序的層面來說，新的Entry插入到雙向連結串列的尾部，可以實現按照插入的先後順序來迭代Entry，而從訪問順序的層面來說，新put進來的Entry又是最近訪問的Entry，也應該將其放在雙向連結串列的尾部。

    上面還有個removeEldestEntry方法，該方法如下：

1. //該方法是用來被覆寫的，一般如果用LinkedHashmap實現LRU演算法，就要覆寫該方法，
2.     //比如可以將該方法覆寫為如果設定的記憶體已滿，則返回true，這樣當再次向LinkedHashMap中put
3.     //Entry時，在呼叫的addEntry方法中便會將近期最少使用的節點刪除掉（header後的那個節點）。
4.     protectedboolean removeEldestEntry(Map.Entry<K,V> eldest) {  
5.         returnfalse;  
6.     }  
7. }  

該方法預設返回false，我們一般在用LinkedHashMap實現LRU演算法時，要覆寫該方法，一般的實現是，當設定的記憶體（這裡指節點個數）達到最大值時，返回true，這樣put新的Entry（該Entry的key在雜湊表中沒有已經存在）時，就會呼叫removeEntryForKey方法，將最近最少使用的節點刪除（head後面的那個節點，實際上是最近沒有使用）。
    6、LinkedHashMap覆寫了HashMap的get方法：

1. //覆寫HashMap中的get方法，通過getEntry方法獲取Entry物件。
2. //注意這裡的recordAccess方法，
3. //如果連結串列中元素的排序規則是按照插入的先後順序排序的話，該方法什麼也不做，
4. //如果連結串列中元素的排序規則是按照訪問的先後順序排序的話，則將e移到連結串列的末尾處。
5.    public V get(Object key) {  
6.        Entry<K,V> e = (Entry<K,V>)getEntry(key);  
7.        if (e == null)  
8.            returnnull;  
9.        e.recordAccess(this);  
10.        return e.value;  
11.    }  

    先取得Entry，如果不為null，一樣呼叫recordAccess方法，上面已經說得很清楚，這裡不在多解釋了。

    7、最後說說LinkedHashMap是如何實現LRU的。首先，當accessOrder為true時，才會開啟按訪問順序排序的模式，才能用來實現LRU演算法。我們可以看到，無論是put方法還是get方法，都會導致目標Entry成為最近訪問的Entry，因此便把該Entry加入到了雙向連結串列的末尾（get方法通過呼叫recordAccess方法來實現，put方法在覆蓋已有key的情況下，也是通過呼叫recordAccess方法來實現，在插入新的Entry時，則是通過createEntry中的addBefore方法來實現），這樣便把最近使用了的Entry放入到了雙向連結串列的後面，多次操作後，雙向連結串列前面的Entry便是最近沒有使用的，這樣當節點個數滿的時候，刪除的最前面的Entry(head後面的那個Entry)便是最近最少使用的Entry。