一、LinkedHashMap解讀
LinkedHashMap類的層次結構：
LinkedHashMap實現了Map<K,V>接口，繼承HashMap類。
LinkedHashMap繼承自HashMap，底層數據結構大體相似，都有數組+單向鏈表+紅黑樹，LinkedHashMap在此數據結構上新添加維護了一條雙向鏈表，把所有的元素通過雙向鏈表連接起來，比HashMap多了元素的順序（添加順序）。所以可以說linkedHashMap的數據結構爲：數組+單向鏈表+紅黑樹+雙向鏈表。添加了雙向鏈表雖然增加了時間和空間上的開銷，但是通過維護一個運行於所有元素的雙向鏈表，使得linkedHashMap保證了元素的添加順序和迭代順序。LinkedHashMap絕大部分方法都是繼承自父類HashMap，比如關鍵的put(k,v)方法，僅爲維護雙向鏈表覆寫了部分方法。但LinkedHashMap的5個構造方法內部也是通過super關鍵字調用父類HashMap構造方法來做初始化。所以，建議要看LinkedHashMap源碼的話先讀懂HashMap源碼，徹底瞭解其數據結構，可以參考上篇博客源碼解析java集合框架，HashMap源碼。
linkedHashMap結構如下：
二、源碼解讀
LinkedHashMap對元素的增刪改查等操作大多基於其父類HashMap中的方法，只是實現的細節有所不同，而LinkedHashMap所做的是使用雙向鏈表維護元素的插入順序，在LinkedHashMap類源碼中看不到put、remove等方法，都是直接使用父類HashMap中的方法。
2.1 構造方法
public LinkedHashMap(int initialCapacity, float loadFactor) {
super(initialCapacity, loadFactor);
accessOrder = false; //爲false代表LinkedHashMap保持插入順序
}
public LinkedHashMap(int initialCapacity) {
super(initialCapacity);
accessOrder = false;
}
public LinkedHashMap() {
super();
accessOrder = false;
}
/**
* The iteration ordering method for this linked hash map: <tt>true</tt>
* for access-order, <tt>false</tt> for insertion-order.
* 爲false代表保持插入順序，true訪問順序
*/
final boolean accessOrder;
LinkedHashMap構造方法內部都是super調用父類HashMap構造方法，HashMap構造方法只有給常量賦值操作，沒有任何構建操作，如下其中一個：
public HashMap(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
this.loadFactor = loadFactor;
this.threshold = tableSizeFor(initialCapacity);
}
2.2 添加元素put(k,v)方法
新建一個LinkedHashMap對象，調用put方法，會發現使用的是HashMap的put方法：
LinkedHashMap<String, String> lhm = new LinkedHashMap<>();
lhm.put("cn","china");
HashMap中put(k,v)源碼：
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; //新建數組桶，未初始化
Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0) //當數組table爲空時
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null) //根據hash值定位數組桶的位置，
//如果該位置爲空，沒有數據時，則使用傳入的key、value、hash值新建Node對象，放置在該位置。
tab[i] = newNode(hash, key, value, null);
else { //當桶位置上有數據時
Node<K,V> e; K k;
//插入的元素與桶所在位置第一個元素相比，hash值相等，key相等時
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//hash值不相等或key不相等時
else if (p instanceof TreeNode) //判斷是紅黑樹時
//把元素放入數中
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
//第三種情況只有爲鏈表
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {//下一個元素爲null，即爲鏈表末端時
p.next = newNode(hash, key, value, null);//末端插入元素
//鏈表節點數量到達閾值8個時則轉爲紅黑樹
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash); //轉爲紅黑樹
break;//跳出循環
}
//判斷鏈表中結點的key值與插入的元素的key值是否相等
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break; //相等，則跳出循環
p = e;
}
}
//當在桶中找到key值、hash值與插入元素相等的元素時，覆蓋元素的value值
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
//判斷是否需要擴容，超過限定值則調用resize()方法擴容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
LinkedHashMap爲了雙鏈表的實現，重寫了HashMap一些方法，供putVal()方法調用。
2.2.1 LinkedHashMap的newNode(h, k, v, null)方法
在putVal()方法中，有對方法newNode(h, k, v, null)的調用，新建桶中元素並放入桶中。LinkedHashMap重寫了newNode(h, k, v, null)方法，重寫如下：
//LinkedHashMap新建桶元素node
Node<K,V> newNode(int hash, K key, V value, Node<K,V> e) {
LinkedHashMap.Entry<K,V> p =
new LinkedHashMap.Entry<K,V>(hash, key, value, e);
linkNodeLast(p); //設置了桶元素後，維護該元素雙向鏈表，把元素插入到雙向鏈表中
return p;
}
// link at the end of list
private void linkNodeLast(LinkedHashMap.Entry<K,V> p) {
LinkedHashMap.Entry<K,V> last = tail; //鏈表尾
tail = p; //元素插到尾部
if (last == null) //當鏈表尾爲空時，頭也爲空，把當前元素設置爲頭
head = p;
else { //鏈表尾不爲空時，修改前後指針，插入到鏈表中
p.before = last;
last.after = p;
}
}
/**
* The head (eldest) of the doubly linked list.
* LinkedHashMap雙向鏈表頭
*/
transient LinkedHashMap.Entry<K,V> head;
/**
* The tail (youngest) of the doubly linked list.
* LinkedHashMap雙向鏈表尾
*/
transient LinkedHashMap.Entry<K,V> tail;
再來看LinkedHashMap的Entry對象，LinkedHashMap每個節點都是一個Entry對象，它繼承了HashMap.Node<K,V>，但比Node多了兩屬性Entry<K,V> before, after，用來存儲前後元素，實現雙鏈表：
/**
* HashMap.Node subclass for normal LinkedHashMap entries.
*/
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);
}
}
之前也介紹過，HashMap.Node中包含了int hash、K k、V v、Node<K,V> next，實現了HashMap的單鏈表，LinkedHashMap.Entry在此基礎上增加了前後兩個指針域，形成雙向鏈表，之前的單鏈表依然存在。
2.2.2 插入樹元素時，LinkedHashMap同樣進行了重寫操作，重寫newTreeNode()方法
TreeNode<K,V> newTreeNode(int hash, K key, V value, Node<K,V> next) {
TreeNode<K,V> p = new TreeNode<K,V>(hash, key, value, next);
linkNodeLast(p); //維護鏈表
return p;
}
2.2.3 afterNodeAccess()方法和afterNodeInsertion()方法
LinkedHashMap重寫了afterNodeAccess和afterNodeInsertion方法，自己維護鏈表關係。
2.3 刪除元素remove(Object key)方法
LinkedHashMap刪除元素調用的也是父類HashMap的remove()方法：
public V remove(Object key) {
Node<K,V> e;
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}
final Node<K,V> removeNode(int hash, Object key, Object value,
boolean matchValue, boolean movable) {
Node<K,V>[] tab; Node<K,V> p; int n, index;
//如果數組tab不爲空、長度大於0、根據hash值對應位置數據不爲空
if ((tab = table) != null && (n = tab.length) > 0 &&
(p = tab[index = (n - 1) & hash]) != null) {
Node<K,V> node = null, e; K k; V v;
//如果當前節點key和傳入key相等，那麼當前節點就是要刪除的節點，賦值給node
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
node = p;
//桶中元素未匹配上，需檢查後面數據，有可能爲樹，有可能爲鏈表
else if ((e = p.next) != null) {
//如果後面節點爲樹，則使用樹獲取節點方法匹配數據，返回給node
if (p instanceof TreeNode)
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
//不是數，則爲鏈表，迭代匹配數據，匹配到返回給node
else {
do {
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
node = e;
break;
}
p = e;
} while ((e = e.next) != null);
}
}
//對node判斷，node不爲空，說明根據key匹配到了要刪除的節點數據，
//刪除node
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) {
//如果要刪除的節點是樹節點，調用移除樹節點方法
if (node instanceof TreeNode)
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
//如果該節點是桶中元素，則使用賦值node.next的方式刪除該節點
else if (node == p)
tab[index] = node.next;
//是鏈表的話移動指針即可
else
p.next = node.next;
++modCount; //hashmap修改次數
--size; //hashmap元素個數
afterNodeRemoval(node);
return node;
}
}
return null;
}
LinkedHashMap重寫了afterNodeRemoval()方法，
void afterNodeRemoval(Node<K,V> e) { // unlink
LinkedHashMap.Entry<K,V> p =
(LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
p.before = p.after = null;
if (b == null)
head = a;
else
b.after = a;
if (a == null)
tail = b;
else
a.before = b;
}
這個方法是LinkedHashMap重新維護雙向鏈表元素的前後關係。
2.4 獲取元素get(Object key)方法
public V get(Object key) {
Node<K,V> e;
if ((e = getNode(hash(key), key)) == null)
return null;
if (accessOrder)
afterNodeAccess(e);
return e.value;
}
LinkedHashMap有定義自己的get方法，但是getNode()方法還是調用的HashMap中的。LinkedHashMap中根據accessOrder的值來決定是否調用afterNodeAccess方法，爲true，就會重新進行雙向鏈表的維護優化，將最近一次訪問的元素置於雙向鏈表的尾部，作爲緩存。
後語，LinkedHashMap可以說是HashMap的延伸，在HashMap的基礎上加了雙向鏈表，使得有了順序，彌補了HashMap無序的不足，同時，在實現上基本是使用HashMap作爲母體，只是針對雙向鏈表做了自我實現。
與HashMap相比，LinkedHashMap在空間和時間上是劣勢，但實現了有序。