LinkedHashMap
简介
先来回顾一下 HashMap 的特性：
① 基于 JDK1.8 的 HashMap 是由数组 + 链表 + 红黑树组成，相对于早期版本的 JDK HashMap 实现，新增了红黑树作为底层数据结构，在数据量较大且哈希碰撞较多时，能够极大的增加检索的效率。
② 允许 key 和 value 都为 null。key 重复会被覆盖，value 允许重复。
③ 非线程安全。
④ 无序（遍历 HashMap 得到元素的顺序不是按照插入的顺序）。
LinkedHashMap 是基于 HashMap 实现的一种集合，具有 HashMap 集合上面所说的所有特点，除了 HashMap 无序的特点，LinkedHashMap 是有序的，因为 LinkedHashMap 在 HashMap 的基础上单独维护了一个具有所有数据的双向链表，该链表保证了元素迭代的顺序。
所以我们可以直接这样说：LinkedHashMap = HashMap + LinkedList。LinkedHashMap 就是在 HashMap 的基础上多维护了一个双向链表，用来保证元素迭代顺序。
1public class LinkedHashMap<K,V> extends HashMap<K,V> implements Map<K,V>
字段属性
Entry<K,V>
1static class Entry<K,V> extends HashMap.Node<K,V> {
2 Entry<K,V> before, after;
3 Entry(int hash, K key, V value, Node<K,V> next) {
4 super(hash, key, value, next);
5 }
6}
LinkedHashMap 的每个元素都是一个 Entry，我们看到对于 Entry 继承自 HashMap 的 Node 结构，相对于 Node 结构，LinkedHashMap 多了 before 和 after 结构。
下面是Map类集合基本元素的实现演变：
LinkedHashMap 中 Entry 相对于 HashMap 多出的 before 和 after 便是用来维护 LinkedHashMap 插入 Entry 的先后顺序的。
其它属性
用来指向双向链表的头节点：
1transient LinkedHashMap.Entry<K,V> head;
用来指向双向链表的尾节点：
1transient LinkedHashMap.Entry<K,V> tail;
用来指定LinkedHashMap的迭代顺序：
1final boolean accessOrder;
-
true表示按照访问顺序，会把访问过的元素放在链表后面，放置顺序是访问的顺序； -
false表示按照插入顺序遍历。
注意：这里有五个属性别搞混淆：
- 对于
Node next属性，是用来维护整个集合中 Entry 的顺序； - 对于
Entry before，Entry after，以及Entry head，Entry tail，这四个属性都是用来维护保证集合顺序的链表。其中前两个 before 和 after 表示某个节点的上一个节点和下一个节点，这是一个双向链表。后两个属性 head 和 tail 分别表示这个链表的头节点和尾节点。
构造函数
无参构造函数
1public LinkedHashMap() {
2 super();
3 accessOrder = false; //默认按照插入的顺序
4}
指定初始容量
1public LinkedHashMap(int initialCapacity) {
2 super(initialCapacity);
3 accessOrder = false;
4}
指定初始容量、装载因子
1public LinkedHashMap(int initialCapacity, float loadFactor) {
2 super(initialCapacity, loadFactor);
3 accessOrder = false;
4}
指定初始容量、加载因子、迭代规则
1public LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder) {
2 super(initialCapacity, loadFactor);
3 this.accessOrder = accessOrder;
4}
构造包含指定集合中的元素
1public LinkedHashMap(Map<? extends K, ? extends V> m) {
2 super();
3 accessOrder = false;
4 putMapEntries(m, false);
5}
上面所有的构造函数默认 accessOrder = false，除了第四个构造函数能够指定 accessOrder 的值。
添加元素
LinkedHashMap 中是没有 put 方法的，而是直接调用父类 HashMap 的 put 方法。关于 HashMap 的 put 方法，可以参看 HashMap 的介绍
LinkedHashMap
1public V put(K key, V value) {
2 return putVal(hash(key), key, value, false, true);
3}
HashMap
1public V put(K key, V value) {
2 return putVal(hash(key), key, value, false, true);
3}
4
5/**
6 * @param hash 索引的位置
7 * @param key 键
8 * @param value 值
9 * @param onlyIfAbsent true 表示不要更改现有值
10 * @param evict false 表示table处于创建模式
11 * @return
12 */
13final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
14 Node<K,V>[] tab;
15 Node<K,V> p;
16 int n, i;
17 //如果table为null或者长度为0，则进行初始化
18 //resize()方法本来是用于扩容，由于初始化没有实际分配空间，这里用该方法进行空间分配，后面会详细讲解该方法
19 if ((tab = table) == null || (n = tab.length) == 0)
20 n = (tab = resize()).length;
21 //注意：这里用到了前面讲解获得key的hash码的第三步，取模运算，下面的if-else分别是 tab[i] 为null和不为null
22 if ((p = tab[i = (n - 1) & hash]) == null)
23 tab[i] = newNode(hash, key, value, null); //tab[i] 为null，直接将新的key-value插入到计算的索引i位置 ①
24 else { //tab[i] 不为null，表示该位置已经有值了
25 Node<K,V> e; K k;
26 if (p.hash == hash &&
27 ((k = p.key) == key || (key != null && key.equals(k))))
28 e = p; //节点key已经有值了，直接用新值覆盖
29 //该链是红黑树
30 else if (p instanceof TreeNode)
31 e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value); // ②
32 //该链是链表
33 else {
34 for (int binCount = 0; ; ++binCount) {
35 if ((e = p.next) == null) {
36 p.next = newNode(hash, key, value, null);
37 //链表长度大于8，转换成红黑树
38 if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
39 treeifyBin(tab, hash);
40 break;
41 }
42 //key已经存在直接覆盖value
43 if (e.hash == hash &&
44 ((k = e.key) == key || (key != null && key.equals(k))))
45 break;
46 p = e;
47 }
48 }
49 if (e != null) { // existing mapping for key
50 V oldValue = e.value;
51 if (!onlyIfAbsent || oldValue == null)
52 e.value = value;
53 afterNodeAccess(e); // ③
54 return oldValue;
55 }
56 }
57 ++modCount; //用作修改和新增快速失败
58 if (++size > threshold) resize(); //超过最大容量，进行扩容
59 afterNodeInsertion(evict); // ④
60 return null;
61}
这里主要介绍上面方法中，为了保证 LinkedHashMap 的迭代顺序，在添加元素时重写了的4个方法，分别位于① ② ③ ④ 处
1newNode(hash, key, value, null); // ①
2putTreeVal(this, tab, hash, key, value) // ② newTreeNode(h, k, v, xpn)
3afterNodeAccess(e); // ③
4afterNodeInsertion(evict); // ④
① 对于
newNode(hash, key, value, null)方法
1HashMap.Node<K,V> newNode(int hash, K key, V value, HashMap.Node<K,V> e) {
2 LinkedHashMap.Entry<K,V> p = new LinkedHashMap.Entry<K,V>(hash, key, value, e);
3 linkNodeLast(p);
4 return p;
5}
6
7private void linkNodeLast(LinkedHashMap.Entry<K,V> p) {
8 //用临时变量last记录尾节点tail
9 LinkedHashMap.Entry<K,V> last = tail;
10 //将尾节点设为当前插入的节点p
11 tail = p;
12 //如果原先尾节点为null，表示当前链表为空
13 if (last == null)
14 //头结点也为当前插入节点
15 head = p;
16 else {
17 //原始链表不为空，那么将当前节点的上节点指向原始尾节点
18 p.before = last;
19 //原始尾节点的下一个节点指向当前插入节点
20 last.after = p;
21 }
22}
② 对于
putTreeVal方法
是在添加红黑树节点时的操作，LinkedHashMap 也重写了该方法的 newTreeNode 方法：
1TreeNode<K,V> newTreeNode(int hash, K key, V value, Node<K,V> next) {
2 TreeNode<K,V> p = new TreeNode<K,V>(hash, key, value, next);
3 linkNodeLast(p);
4 return p;
5}
也就是说上面两个方法都是在将新添加的元素放置到链表的尾端，并维护链表节点之间的关系。
③ 对于
afterNodeAccess(e)方法
在 putVal 方法中，是当添加数据键值对的 key 存在时，会对 value 进行替换。然后调用 afterNodeAccess(e) 方法：
1//把当前节点放到双向链表的尾部
2void afterNodeAccess(HashMap.Node<K,V> e) { // move node to last
3 LinkedHashMap.Entry<K,V> last;
4 //当 accessOrder = true 并且当前节点不等于尾节点tail。这里将last节点赋值为tail节点
5 if (accessOrder && (last = tail) != e) {
6 //记录当前节点的上一个节点b和下一个节点a
7 LinkedHashMap.Entry<K,V> p =
8 (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
9 //释放当前节点和后一个节点的关系
10 p.after = null;
11 //如果当前节点的前一个节点为null
12 if (b == null)
13 //头节点=当前节点的下一个节点
14 head = a;
15 else
16 //否则b的后节点指向a
17 b.after = a;
18 //如果a != null
19 if (a != null)
20 //a的前一个节点指向b
21 a.before = b;
22 else
23 //b设为尾节点
24 last = b;
25 //如果尾节点为null
26 if (last == null)
27 //头节点设为p
28 head = p;
29 else {
30 //否则将p放到双向链表的最后
31 p.before = last;
32 last.after = p;
33 }
34 //将尾节点设为p
35 tail = p;
36 //LinkedHashMap对象操作次数+1，用于快速失败校验
37 ++modCount;
38 }
39}
该方法是在 accessOrder = true 并且插入的当前节点不等于尾节点时，该方法才会生效。并且该方法的作用是将插入的节点变为尾节点，后面在 get 方法中也会调用。代码实现可能有点绕，可以借助下图来理解：
④ 再看 afterNodeInsertion(evict) 方法
1void afterNodeInsertion(boolean evict) { // possibly remove eldest
2 LinkedHashMap.Entry<K,V> first;
3 if (evict && (first = head) != null && removeEldestEntry(first)) {
4 K key = first.key;
5 removeNode(hash(key), key, null, false, true);
6 }
7}
该方法用来移除最老的首节点，首先方法要能执行到if语句里面，必须 evict = true，且头节点不为null，并且 removeEldestEntry(first) 返回true，这三个条件必须同时满足，前面两个好理解，我们看最后这个方法条件：
1protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
2 return false;
3}
这就奇怪了，该方法直接返回的是 false，也就是说怎么都不会进入到 if 方法体内了，那这是这么回事呢？
这其实是用来实现 LRU（Least Recently Used，最近最少使用）Cache 时，重写的一个方法。比如在 mybatis-connector 包中，有这样一个类：
1package com.mysql.jdbc.util;
2
3import java.util.LinkedHashMap;
4import java.util.Map.Entry;
5
6public class LRUCache<K, V> extends LinkedHashMap<K, V> {
7 private static final long serialVersionUID = 1L;
8 protected int maxElements;
9
10 public LRUCache(int maxSize) {
11 super(maxSize, 0.75F, true);
12 this.maxElements = maxSize;
13 }
14
15 protected boolean removeEldestEntry(Entry<K, V> eldest) {
16 return this.size() > this.maxElements;
17 }
18}
可以看到，它重写了 removeEldestEntry(Entry<K,V> eldest) 方法，当元素的个数大于设定的最大个数，便移除首元素。
删除元素
同理也是调用 HashMap 的remove 方法，这里不作过多的讲解，着重看 LinkedHashMap 重写的 ① 方法。
1final Node<K,V> removeNode(int hash, Object key, Object value,
2 boolean matchValue, boolean movable) {
3 Node<K,V>[] tab; Node<K,V> p; int n, index;
4 //(n - 1) & hash找到桶的位置
5 if ((tab = table) != null && (n = tab.length) > 0 &&
6 (p = tab[index = (n - 1) & hash]) != null) {
7 Node<K,V> node = null, e; K k; V v;
8
9 //如果键的值与链表第一个节点相等，则将 node 指向该节点
10 if (p.hash == hash &&
11 ((k = p.key) == key || (key != null && key.equals(k))))
12 node = p;
13 //如果桶节点存在下一个节点
14 else if ((e = p.next) != null) {
15 //节点为红黑树
16 if (p instanceof TreeNode)
17 node = ((TreeNode<K,V>)p).getTreeNode(hash, key); //找到需要删除的红黑树节点
18 else {
19 do { //遍历链表，找到待删除的节点
20 if (e.hash == hash &&
21 ((k = e.key) == key ||
22 (key != null && key.equals(k)))) {
23 node = e;
24 break;
25 }
26 p = e;
27 } while ((e = e.next) != null);
28 }
29 }
30
31 //删除节点，并进行调节红黑树平衡
32 if (node != null && (!matchValue || (v = node.value) == value ||
33 (value != null && value.equals(v)))) {
34 if (node instanceof TreeNode)
35 ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
36 else if (node == p)
37 tab[index] = node.next;
38 else
39 p.next = node.next;
40 ++modCount;
41 --size;
42 afterNodeRemoval(node); // ①
43 return node;
44 }
45 }
46 return null;
47}
我们看 ① 代码实现：
1void afterNodeRemoval(HashMap.Node<K,V> e) { // unlink
2 LinkedHashMap.Entry<K,V> p =
3 (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
4 p.before = p.after = null;
5 if (b == null)
6 head = a;
7 else
8 b.after = a;
9 if (a == null)
10 tail = b;
11 else
12 a.before = b;
13}
该方法其实很好理解，就是当我们删除某个节点时，为了保证链表还是有序的，那么必须维护其前后节点。而该方法的作用就是维护删除节点的前后节点关系。
查找元素
1public V get(Object key) {
2 Node<K,V> e;
3 if ((e = getNode(hash(key), key)) == null)
4 return null;
5 if (accessOrder)
6 afterNodeAccess(e);
7 return e.value;
8}
相比于 HashMap 的 get 方法，这里多出了第 5,6行代码，当 accessOrder = true 时，即表示按照最近访问的迭代顺序，会将访问过的元素放在链表后面。
对于 afterNodeAccess(e) 方法，在前面第 4 小节 添加元素已经介绍过了，这就不再介绍。
遍历元素
在介绍 HashMap 时，我们介绍了 4 中遍历方式，同理，对于 LinkedHashMap 也有 4 种，这里我们介绍效率较高的两种遍历方式：
- 得到 Entry 集合，然后遍历 Entry
1LinkedHashMap<String,String> map = new LinkedHashMap<>();
2map.put("A","1");
3map.put("B","2");
4map.put("C","3");
5map.get("B");
6Set<Map.Entry<String,String>> entrySet = map.entrySet();
7for(Map.Entry<String,String> entry : entrySet ){
8 System.out.println(entry.getKey()+"---"+entry.getValue());
9}
- 迭代
1Iterator<Map.Entry<String,String>> iterator = map.entrySet().iterator();
2while(iterator.hasNext()){
3 Map.Entry<String,String> entry = iterator.next();
4 System.out.println(entry.getKey()+"----"+entry.getValue());
5}
这两种效率都还不错，通过迭代的方式可以对一边遍历一边删除元素，而第一种删除元素会报错。
打印结果：
1A---1
2B---2
3C---3
4A---1
5B---2
6C---3
迭代器
我们把上面遍历的LinkedHashMap 构造函数改成下面的：
1LinkedHashMap<String,String> map = new LinkedHashMap<>(16,0.75F,true);
也就是说将 accessOrder = true，表示按照访问顺序来遍历，注意看上面的 第 5 行代码：map.get("B")。也就是说设置 accessOrder = true 之后，那么 B—2 应该是最后输出，我们看一下打印结果：
1A---1
2C---3
3B---2
结果跟预期一致。那么在遍历的过程中，LinkedHashMap 是如何进行的呢？
我们追溯源码：首先进入到 map.entrySet() 方法里面：
1public Set<Map.Entry<K,V>> entrySet() {
2 Set<Map.Entry<K,V>> es;
3 return (es = entrySet) == null ? (entrySet = new LinkedEntrySet()) : es;
4}
发现 entrySet = new LinkedEntrySet() ，接下来我们查看 LinkedEntrySet 类。
1final class LinkedEntrySet extends AbstractSet<Map.Entry<K,V>> {
2 public final int size() { return size; }
3 public final void clear() { LinkedHashMap.this.clear(); }
4 public final Iterator<Map.Entry<K,V>> iterator() {
5 return new LinkedEntryIterator();
6 }
7 ...
8}
这是一个内部类，我们查看其 iterator() 方法，发现又new 了一个新对象 LinkedEntryIterator，接着看这个类：
1final class LinkedEntryIterator extends LinkedHashIterator
2 implements Iterator<Map.Entry<K,V>> {
3 public final Map.Entry<K,V> next() { return nextNode(); }
4}
这个类继承 LinkedHashIterator。
1abstract class LinkedHashIterator {
2 LinkedHashMap.Entry<K,V> next;
3 LinkedHashMap.Entry<K,V> current;
4 int expectedModCount;
5
6 LinkedHashIterator() {
7 next = head;
8 expectedModCount = modCount;
9 current = null;
10 }
11
12 public final boolean hasNext() {
13 return next != null;
14 }
15
16 final LinkedHashMap.Entry<K,V> nextNode() {
17 LinkedHashMap.Entry<K,V> e = next;
18 if (modCount != expectedModCount)
19 throw new ConcurrentModificationException();
20 if (e == null)
21 throw new NoSuchElementException();
22 current = e;
23 next = e.after;
24 return e;
25 }
26
27 public final void remove() {
28 Node<K,V> p = current;
29 if (p == null)
30 throw new IllegalStateException();
31 if (modCount != expectedModCount)
32 throw new ConcurrentModificationException();
33 current = null;
34 K key = p.key;
35 removeNode(hash(key), key, null, false, false);
36 expectedModCount = modCount;
37 }
38}
看到 nextNode() 方法，很显然是通过遍历链表的方式来遍历整个 LinkedHashMap 。
