1 前言

LinkedHashMap繼承于HashMap，如果對HashMap原理還不清楚的同學，請先看上一篇：圖解HashMap原理

2 LinkedHashMap使用與實現

先來一張LinkedHashMap的結構圖，不要虛，看完文章再來看這個圖，就秒懂了，先混個面熟

2.1 應用場景
HashMap是無序的，當我們希望有順序地去存儲key-value時，就需要使用LinkedHashMap了。

Map<String, String> hashMap = new HashMap<String, String>();hashMap.put("name1", "josan1");hashMap.put("name2", "josan2");hashMap.put("name3", "josan3");Set<Entry<String, String>> set = hashMap.entrySet();Iterator<Entry<String, String>> iterator = set.iterator();while(iterator.hasNext()) {Entry entry = iterator.next();String key = (String) entry.getKey();String value = (String) entry.getValue();System.out.println("key:" + key + ",value:" + value);}

我們是按照xxx1、xxx2、xxx3的順序插入的，但是輸出結果并不是按照順序的。

同樣的數據，我們再試試LinkedHashMap

Map<String, String> linkedHashMap = new LinkedHashMap<>();linkedHashMap.put("name1", "josan1");linkedHashMap.put("name2", "josan2");linkedHashMap.put("name3", "josan3");Set<Entry<String, String>> set = linkedHashMap.entrySet();Iterator<Entry<String, String>> iterator = set.iterator();while(iterator.hasNext()) {Entry entry = iterator.next();String key = (String) entry.getKey();String value = (String) entry.getValue();System.out.println("key:" + key + ",value:" + value);}

結果可知，LinkedHashMap是有序的，且默認為插入順序。

2.2 簡單使用
跟HashMap一樣，它也是提供了key-value的存儲方式，并提供了put和get方法來進行數據存取。

LinkedHashMap<String, String> linkedHashMap = new LinkedHashMap<>();linkedHashMap.put("name", "josan");String name = linkedHashMap.get("name");

2.3 定義
LinkedHashMap繼承了HashMap，所以它們有很多相似的地方。

public class LinkedHashMap<K,V>extends HashMap<K,V>implements Map<K,V> {

2.4 構造方法

LinkedHashMap提供了多個構造方法，我們先看空參的構造方法。

public LinkedHashMap() {// 調用HashMap的構造方法，其實就是初始化Entry[] tablesuper();// 這里是指是否基于訪問排序，默認為falseaccessOrder = false;}

首先使用super調用了父類HashMap的構造方法，其實就是根據初始容量、負載因子去初始化Entry[] table，詳細的看上一篇HashMap解析。

然后把accessOrder設置為false，這就跟存儲的順序有關了，LinkedHashMap存儲數據是有序的，而且分為兩種：插入順序和訪問順序。

這里accessOrder設置為false，表示不是訪問順序而是插入順序存儲的，這也是默認值，表示LinkedHashMap中存儲的順序是按照調用put方法插入的順序進行排序的。LinkedHashMap也提供了可以設置accessOrder的構造方法，我們來看看這種模式下，它的順序有什么特點？

// 第三個參數用于指定accessOrder值Map<String, String> linkedHashMap = new LinkedHashMap<>(16, 0.75f, true);linkedHashMap.put("name1", "josan1");linkedHashMap.put("name2", "josan2");linkedHashMap.put("name3", "josan3");System.out.println("開始時順序：");Set<Entry<String, String>> set = linkedHashMap.entrySet();Iterator<Entry<String, String>> iterator = set.iterator();while(iterator.hasNext()) {Entry entry = iterator.next();String key = (String) entry.getKey();String value = (String) entry.getValue();System.out.println("key:" + key + ",value:" + value);}System.out.println("通過get方法，導致key為name1對應的Entry到表尾");linkedHashMap.get("name1");Set<Entry<String, String>> set2 = linkedHashMap.entrySet();Iterator<Entry<String, String>> iterator2 = set2.iterator();while(iterator2.hasNext()) {Entry entry = iterator2.next();String key = (String) entry.getKey();String value = (String) entry.getValue();System.out.println("key:" + key + ",value:" + value);}

因為調用了get(“name1”)導致了name1對應的Entry移動到了最后，這里只要知道LinkedHashMap有插入順序和訪問順序兩種就可以，后面會詳細講原理。

還記得，上一篇HashMap解析中提到，在HashMap的構造函數中，調用了init方法，而在HashMap中init方法是空實現，但LinkedHashMap重寫了該方法，所以在LinkedHashMap的構造方法里，調用了自身的init方法，init的重寫實現如下：

/*** Called by superclass constructors and pseudoconstructors (clone,* readObject) before any entries are inserted into the map. Initializes* the chain.*/@Overridevoid init() {// 創建了一個hash=-1，key、value、next都為null的Entryheader = new Entry<>(-1, null, null, null);// 讓創建的Entry的before和after都指向自身，注意after不是之前提到的next// 其實就是創建了一個只有頭部節點的雙向鏈表header.before = header.after = header;}

這好像跟我們上一篇HashMap提到的Entry有些不一樣，HashMap中靜態內部類Entry是這樣定義的：

static class Entry<K,V> implements Map.Entry<K,V> {final K key;V value;Entry<K,V> next;int hash;

沒有before和after屬性啊！原來，LinkedHashMap有自己的靜態內部類Entry，它繼承了HashMap.Entry，定義如下:

/*** LinkedHashMap entry.*/private static class Entry<K,V> extends HashMap.Entry<K,V> {// These fields comprise the doubly linked list used for iteration.Entry<K,V> before, after;Entry(int hash, K key, V value, HashMap.Entry<K,V> next) {super(hash, key, value, next);}

所以LinkedHashMap構造函數，主要就是調用HashMap構造函數初始化了一個Entry[] table，然后調用自身的init初始化了一個只有頭結點的雙向鏈表。完成了如下操作：

2.5 put方法
LinkedHashMap沒有重寫put方法，所以還是調用HashMap得到put方法，如下：

public V put(K key, V value) {// 對key為null的處理if (key == null)return putForNullKey(value);// 計算hashint hash = hash(key);// 得到在table中的indexint i = indexFor(hash, table.length);// 遍歷table[index]，是否key已經存在，存在則替換，并返回舊值for (Entry<K,V> e = table[i]; e != null; e = e.next) {Object k;if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {V oldValue = e.value;e.value = value;e.recordAccess(this);return oldValue;}}modCount++;// 如果key之前在table中不存在，則調用addEntry，LinkedHashMap重寫了該方法addEntry(hash, key, value, i);return null;}

我們看看LinkedHashMap的addEntry方法：

void addEntry(int hash, K key, V value, int bucketIndex) {// 調用父類的addEntry，增加一個Entry到HashMap中super.addEntry(hash, key, value, bucketIndex);// removeEldestEntry方法默認返回false，不用考慮Entry<K,V> eldest = header.after;if (removeEldestEntry(eldest)) {removeEntryForKey(eldest.key);}}

這里調用了父類HashMap的addEntry方法，如下：

void addEntry(int hash, K key, V value, int bucketIndex) {// 擴容相關if ((size >= threshold) && (null != table[bucketIndex])) {resize(2 * table.length);hash = (null != key) ? hash(key) : 0;bucketIndex = indexFor(hash, table.length);}// LinkedHashMap進行了重寫createEntry(hash, key, value, bucketIndex);}

前面是擴容相關的代碼，在上一篇HashMap解析中已經講過了。這里主要看createEntry方法，LinkedHashMap進行了重寫。

void createEntry(int hash, K key, V value, int bucketIndex) {HashMap.Entry<K,V> old = table[bucketIndex];// e就是新創建了Entry，會加入到table[bucketIndex]的表頭Entry<K,V> e = new Entry<>(hash, key, value, old);table[bucketIndex] = e;// 把新創建的Entry，加入到雙向鏈表中e.addBefore(header);size++;}

我們來看看LinkedHashMap.Entry的addBefore方法：

private void addBefore(Entry<K,V> existingEntry) {after = existingEntry;before = existingEntry.before;before.after = this;after.before = this;}

從這里就可以看出，當put元素時，不但要把它加入到HashMap中去，還要加入到雙向鏈表中，所以可以看出LinkedHashMap就是HashMap+雙向鏈表，下面用圖來表示逐步往LinkedHashMap中添加數據的過程，紅色部分是雙向鏈表，黑色部分是HashMap結構，header是一個Entry類型的雙向鏈表表頭，本身不存儲數據。

首先是只加入一個元素Entry1，假設index為0：

當再加入一個元素Entry2，假設index為15：

當再加入一個元素Entry3, 假設index也是0：

以上，就是LinkedHashMap的put的所有過程了，總體來看，跟HashMap的put類似，只不過多了把新增的Entry加入到雙向列表中。
2.6 擴容
在HashMap的put方法中，如果發現前元素個數超過了擴容閥值時，會調用resize方法，如下：

void resize(int newCapacity) {Entry[] oldTable = table;int oldCapacity = oldTable.length;if (oldCapacity == MAXIMUM_CAPACITY) {threshold = Integer.MAX_VALUE;return;}Entry[] newTable = new Entry[newCapacity];boolean oldAltHashing = useAltHashing;useAltHashing |= sun.misc.VM.isBooted() &&(newCapacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);boolean rehash = oldAltHashing ^ useAltHashing;// 把舊table的數據遷移到新tabletransfer(newTable, rehash);table = newTable;threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);}

LinkedHashMap重寫了transfer方法，數據的遷移，它的實現如下：

void transfer(HashMap.Entry[] newTable, boolean rehash) {// 擴容后的容量是之前的2倍int newCapacity = newTable.length;// 遍歷雙向鏈表，把所有雙向鏈表中的Entry，重新就算hash，并加入到新的table中for (Entry<K,V> e = header.after; e != header; e = e.after) {if (rehash)e.hash = (e.key == null) ? 0 : hash(e.key);int index = indexFor(e.hash, newCapacity);e.next = newTable[index];newTable[index] = e;}}

可以看出，LinkedHashMap擴容時，數據的再散列和HashMap是不一樣的。

HashMap是先遍歷舊table，再遍歷舊table中每個元素的單向鏈表，取得Entry以后，重新計算hash值，然后存放到新table的對應位置。

LinkedHashMap是遍歷的雙向鏈表，取得每一個Entry，然后重新計算hash值，然后存放到新table的對應位置。

從遍歷的效率來說，遍歷雙向鏈表的效率要高于遍歷table，因為遍歷雙向鏈表是N次（N為元素個數）；而遍歷table是N+table的空余個數（N為元素個數）。
2.7 雙向鏈表的重排序
前面分析的，主要是當前LinkedHashMap中不存在當前key時，新增Entry的情況。當key如果已經存在時，則進行更新Entry的value。就是HashMap的put方法中的如下代碼：

for (Entry<K,V> e = table[i]; e != null; e = e.next) {Object k;if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {V oldValue = e.value;e.value = value;// 重排序e.recordAccess(this);return oldValue;}}

主要看e.recordAccess(this)，這個方法跟訪問順序有關，而HashMap是無序的，所以在HashMap.Entry的recordAccess方法是空實現，但是LinkedHashMap是有序的,LinkedHashMap.Entry對recordAccess方法進行了重寫。

void recordAccess(HashMap<K,V> m) {LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;// 如果LinkedHashMap的accessOrder為true，則進行重排序// 比如前面提到LruCache中使用到的LinkedHashMap的accessOrder屬性就為trueif (lm.accessOrder) {lm.modCount++;// 把更新的Entry從雙向鏈表中移除remove();// 再把更新的Entry加入到雙向鏈表的表尾addBefore(lm.header);}}

在LinkedHashMap中，只有accessOrder為true，即是訪問順序模式，才會put時對更新的Entry進行重新排序，而如果是插入順序模式時，不會重新排序，這里的排序跟在HashMap中存儲沒有關系，只是指在雙向鏈表中的順序。

舉個栗子：開始時，HashMap中有Entry1、Entry2、Entry3，并設置LinkedHashMap為訪問順序，則更新Entry1時，會先把Entry1從雙向鏈表中刪除，然后再把Entry1加入到雙向鏈表的表尾，而Entry1在HashMap結構中的存儲位置沒有變化，對比圖如下所示：

2.8 get方法
LinkedHashMap有對get方法進行了重寫，如下：

public V get(Object key) {// 調用genEntry得到EntryEntry<K,V> e = (Entry<K,V>)getEntry(key);if (e == null)return null;// 如果LinkedHashMap是訪問順序的，則get時，也需要重新排序e.recordAccess(this);return e.value;}

先是調用了getEntry方法，通過key得到Entry，而LinkedHashMap并沒有重寫getEntry方法，所以調用的是HashMap的getEntry方法，在上一篇文章中我們分析過HashMap的getEntry方法：首先通過key算出hash值，然后根據hash值算出在table中存儲的index，然后遍歷table[index]的單向鏈表去對比key，如果找到了就返回Entry。

后面調用了LinkedHashMap.Entry的recordAccess方法，上面分析過put過程中這個方法，其實就是在訪問順序的LinkedHashMap進行了get操作以后，重新排序，把get的Entry移動到雙向鏈表的表尾。

2.9 遍歷方式取數據
我們先來看看HashMap使用遍歷方式取數據的過程：

很明顯，這樣取出來的Entry順序肯定跟插入順序不同了，既然LinkedHashMap是有序的，那么它是怎么實現的呢？
先看看LinkedHashMap取遍歷方式獲取數據的代碼：

Map<String, String> linkedHashMap = new LinkedHashMap<>();linkedHashMap.put("name1", "josan1");linkedHashMap.put("name2", "josan2");linkedHashMap.put("name3", "josan3");// LinkedHashMap沒有重寫該方法，調用的HashMap中的entrySet方法Set<Entry<String, String>> set = linkedHashMap.entrySet();Iterator<Entry<String, String>> iterator = set.iterator();while(iterator.hasNext()) {Entry entry = iterator.next();String key = (String) entry.getKey();String value = (String) entry.getValue();System.out.println("key:" + key + ",value:" + value);}

LinkedHashMap沒有重寫entrySet方法，我們先來看HashMap中的entrySet，如下：

public Set<Map.Entry<K,V>> entrySet() {return entrySet0();}private Set<Map.Entry<K,V>> entrySet0() {Set<Map.Entry<K,V>> es = entrySet;return es != null ? es : (entrySet = new EntrySet());}private final class EntrySet extends AbstractSet<Map.Entry<K,V>> {public Iterator<Map.Entry<K,V>> iterator() {return newEntryIterator();}// 無關代碼......}

可以看到，HashMap的entrySet方法，其實就是返回了一個EntrySet對象。

我們得到EntrySet會調用它的iterator方法去得到迭代器Iterator，從上面的代碼也可以看到，iterator方法中直接調用了newEntryIterator方法并返回，而LinkedHashMap重寫了該方法

Iterator<Map.Entry<K,V>> newEntryIterator() { return new EntryIterator();}

這里直接返回了EntryIterator對象，這個和上一篇HashMap中的newEntryIterator方法中一模一樣，都是返回了EntryIterator對象，其實他們返回的是各自的內部類。我們來看看LinkedHashMap中EntryIterator的定義：

private class EntryIterator extends LinkedHashIterator<Map.Entry<K,V>> {public Map.Entry<K,V> next() { return nextEntry();}}

該類是繼承LinkedHashIterator，并重寫了next方法；而HashMap中是繼承HashIterator。
我們再來看看LinkedHashIterator的定義：

private abstract class LinkedHashIterator<T> implements Iterator<T> {// 默認下一個返回的Entry為雙向鏈表表頭的下一個元素Entry<K,V> nextEntry = header.after;Entry<K,V> lastReturned = null;public boolean hasNext() {return nextEntry != header;}Entry<K,V> nextEntry() {if (modCount != expectedModCount)throw new ConcurrentModificationException();if (nextEntry == header)throw new NoSuchElementException();Entry<K,V> e = lastReturned = nextEntry;nextEntry = e.after;return e;}// 不相關代碼......}

我們先不看整個類的實現，只要知道在LinkedHashMap中，Iterator<Entry<String, String>> iterator = set.iterator()，這段代碼會返回一個繼承LinkedHashIterator的Iterator，它有著跟HashIterator不一樣的遍歷規則。

接著，我們會用while(iterator.hasNext())去循環判斷是否有下一個元素，LinkedHashMap中的EntryIterator沒有重寫該方法，所以還是調用LinkedHashIterator中的hasNext方法，如下：

public boolean hasNext() {// 下一個應該返回的Entry是否就是雙向鏈表的頭結點// 有兩種情況：1.LinkedHashMap中沒有元素；2.遍歷完雙向鏈表回到頭部return nextEntry != header;}

nextEntry表示下一個應該返回的Entry，默認值是header.after，即雙向鏈表表頭的下一個元素。而上面介紹到，LinkedHashMap在初始化時，會調用init方法去初始化一個before和after都指向自身的Entry，但是put過程會把新增加的Entry加入到雙向鏈表的表尾，所以只要LinkedHashMap中有元素，第一次調用hasNext肯定不會為false。

然后我們會調用next方法去取出Entry，LinkedHashMap中的EntryIterator重寫了該方法，如下：

public Map.Entry<K,V> next() { return nextEntry(); }

而它自身又沒有重寫nextEntry方法，所以還是調用的LinkedHashIterator中的nextEntry方法：

Entry<K,V> nextEntry() {// 保存應該返回的EntryEntry<K,V> e = lastReturned = nextEntry;//把當前應該返回的Entry的after作為下一個應該返回的EntrynextEntry = e.after;// 返回當前應該返回的Entryreturn e;}

這里其實遍歷的是雙向鏈表，所以不會存在HashMap中需要尋找下一條單向鏈表的情況，從頭結點Entry header的下一個節點開始，只要把當前返回的Entry的after作為下一個應該返回的節點即可。直到到達雙向鏈表的尾部時，after為雙向鏈表的表頭節點Entry header，這時候hasNext就會返回false，表示沒有下一個元素了。LinkedHashMap的遍歷取值如下圖所示：

易知，遍歷出來的結果為Entry1、Entry2…Entry6。
可得，LinkedHashMap是有序的，且是通過雙向鏈表來保證順序的。

2.10 remove方法
LinkedHashMap沒有提供remove方法，所以調用的是HashMap的remove方法，實現如下：

public V remove(Object key) {Entry<K,V> e = removeEntryForKey(key);return (e == null ? null : e.value);}final Entry<K,V> removeEntryForKey(Object key) {int hash = (key == null) ? 0 : hash(key);int i = indexFor(hash, table.length);Entry<K,V> prev = table[i];Entry<K,V> e = prev;while (e != null) {Entry<K,V> next = e.next;Object k;if (e.hash == hash &&((k = e.key) == key || (key != null && key.equals(k)))) {modCount++;size--;if (prev == e)table[i] = next;elseprev.next = next;// LinkedHashMap.Entry重寫了該方法e.recordRemoval(this);return e;}prev = e;e = next;}return e;} 在上一篇HashMap中就分析了remove過程，其實就是斷開其他對象對自己的引用。比如被刪除Entry是在單向鏈表的表頭，則讓它的next放到表頭，這樣它就沒有被引用了；如果不是在表頭，它是被別的Entry的next引用著，這時候就讓上一個Entry的next指向它自己的next，這樣，它也就沒被引用了。在HashMap.Entry中recordRemoval方法是空實現，但是LinkedHashMap.Entry對其進行了重寫，如下：void recordRemoval(HashMap<K,V> m) {remove();}private void remove() {before.after = after;after.before = before;}

易知，這是要把雙向鏈表中的Entry刪除，也就是要斷開當前要被刪除的Entry被其他對象通過after和before的方式引用。

所以，LinkedHashMap的remove操作。首先把它從table中刪除，即斷開table或者其他對象通過next對其引用，然后也要把它從雙向鏈表中刪除，斷開其他對應通過after和before對其引用。

3 HashMap與LinkedHashMap的結構對比

再來看看HashMap和LinkedHashMap的結構圖，是不是秒懂了。LinkedHashMap其實就是可以看成HashMap的基礎上，多了一個雙向鏈表來維持順序。

4 LinkedHashMap在Android中的應用

在Android中使用圖片時，一般會用LruCacha做圖片的內存緩存，它里面就是使用LinkedHashMap來實現存儲的。

public class LruCache<K, V> {private final LinkedHashMap<K, V> map;public LruCache(int maxSize) {if (maxSize <= 0) {throw new IllegalArgumentException("maxSize <= 0");}this.maxSize = maxSize;// 注意第三個參數，是accessOrder，這里為true，后面會講到this.map = new LinkedHashMap<K, V>(0, 0.75f, true);}

前面提到了，accessOrder為true，表示LinkedHashMap為訪問順序，當對已存在LinkedHashMap中的Entry進行get和put操作時，會把Entry移動到雙向鏈表的表尾（其實是先刪除，再插入）。
我們拿LruCache的put方法舉例：

public final V put(K key, V value) {if (key == null || value == null) {throw new NullPointerException("key == null || value == null");}V previous;// 對map進行操作之前，先進行同步操作synchronized (this) {putCount++;size += safeSizeOf(key, value);previous = map.put(key, value);if (previous != null) {size -= safeSizeOf(key, previous);}}if (previous != null) {entryRemoved(false, key, previous, value);}// 整理內存，看是否需要移除LinkedHashMap中的元素trimToSize(maxSize);return previous;}

之前提到了，HashMap是線程不安全的，LinkedHashMap同樣是線程不安全的。所以在對調用LinkedHashMap的put方法時，先使用synchronized 進行了同步操作。

我們最關心的是倒數第一行代碼，其中maxSize為我們給LruCache設置的最大緩存大小。我們看看該方法：

/*** Remove the eldest entries until the total of remaining entries is at or* below the requested size.** @param maxSize the maximum size of the cache before returning. May be -1* to evict even 0-sized elements.*/public void trimToSize(int maxSize) {// while死循環，直到滿足當前緩存大小小于或等于最大可緩存大小while (true) {K key;V value;// 線程不安全，需要同步synchronized (this) {if (size < 0 || (map.isEmpty() && size != 0)) {throw new IllegalStateException(getClass().getName()+ ".sizeOf() is reporting inconsistent results!");}// 如果當前緩存的大小，已經小于等于最大可緩存大小，則直接返回// 不需要再移除LinkedHashMap中的數據if (size <= maxSize || map.isEmpty()) {break;}// 得到的就是雙向鏈表表頭header的下一個EntryMap.Entry<K, V> toEvict = map.entrySet().iterator().next();key = toEvict.getKey();value = toEvict.getValue();// 移除當前取出的Entrymap.remove(key);// 從新計算當前的緩存大小size -= safeSizeOf(key, value);evictionCount++;}entryRemoved(true, key, value, null);}}

從注釋上就可以看出，該方法就是不斷移除LinkedHashMap中雙向鏈表表頭的元素，直到當前緩存大小小于或等于最大可緩存的大小。

由前面的重排序我們知道，對LinkedHashMap的put和get操作，都會讓被操作的Entry移動到雙向鏈表的表尾，而移除是從map.entrySet().iterator().next()開始的，也就是雙向鏈表的表頭的header的after開始的，這也就符合了LRU算法的需求。

下圖表示了LinkedHashMap中刪除、添加、get/put已存在的Entry操作。
紅色表示初始狀態
紫色表示緩存圖片大小超過了最大可緩存大小時，才能夠表頭移除Entry1
藍色表示對已存在的Entry3進行了get/put操作，把它移動到雙向鏈表表尾
綠色表示新增一個Entry7，插入到雙向鏈表的表尾（暫時不考慮在HashMap中的位置）

5 總結

LinkedHashMap是繼承于HashMap，是基于HashMap和雙向鏈表來實現的。
HashMap無序；LinkedHashMap有序，可分為插入順序和訪問順序兩種。如果是訪問順序，那put和get操作已存在的Entry時，都會把Entry移動到雙向鏈表的表尾(其實是先刪除再插入)。
LinkedHashMap存取數據，還是跟HashMap一樣使用的Entry[]的方式，雙向鏈表只是為了保證順序。
LinkedHashMap是線程不安全的。

總結

以上是生活随笔為你收集整理的图解LinkedHashMap原理的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。