深入解析LinkedHashMap
LinkedHashMap是HashMap的一个子类，保存了记录的插入顺序，在用Iterator遍历LinkedHashMap时，先得到的记录肯定是先插入的，也可以在构造时带参数，按照访问次序排序。
public void test(){
Map<String,String> map=new LinkedHashMap<>();
map.put("a","1");
map.put("b","2");
map.put("c","3");
Set<Map.Entry<String, String>> entries = map.entrySet();
for (Map.Entry<String, String> entry : entries) {
System.out.println(entry);
}
}
可以看到，通过遍历Entry发现LinkedHashMap是有序的。在上面的案例中我们展示了LinkedHashMap默认的顺序维持方式（维持插入的顺序），通过重载的构造函数，我们可以将LinkedHashMap设置为维持访问的顺序：
public void test(){
Map<String,String> map=new LinkedHashMap<>(16,0.75f,true);
map.put("a","1");
map.put("b","2");
map.put("c","3");
//获取b后，b节点就会移动到链表的尾部
map.get("b");
Set<Map.Entry<String, String>> entries = map.entrySet();
for (Map.Entry<String, String> entry : entries) {
System.out.println(entry);
}
}
LinkedHashMap维持插入顺序的原理
想要知道LinkedHashMap是如何维持插入顺序的，就需要从其内部类入手解决：
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);
}
}
可以看到，LinkedHashMap中Entry内部类继承与HashMap.Node内部类，LinkedHashMap.Entry类在HashMap.Node的基础上增加了两个指针：before、after。没错，LinkedHashMap就是采用双向链表来维持插入顺序的。LinkedHashMap也提供了两个字段来保存双向链表的头尾的引用。
/**
* The head (eldest) of the doubly linked list.
*/
transient LinkedHashMap.Entry<K,V> head;
/**
* The tail (youngest) of the doubly linked list.
*/
transient LinkedHashMap.Entry<K,V> tail;
如上图，我们依次插入A、B、C、D、E五个Entry，而每次插入时，我们都按照插入顺序维持一个双向链表。我们从head指针开始，顺着after指针走（也就是图中的红色箭头），就可以还原我们的插入顺序。
LinkedHashMap源码解析
在了解完LinkedHashMap基本原理后，我们就来看看它的源码，我们先从它的构造器入手。
构造函数
public LinkedHashMap(int initialCapacity,float loadFactor,boolean accessOrder) {
super(initialCapacity, loadFactor);
this.accessOrder = accessOrder;
}
其中initialCapacity和loadFactor在 《JDK8HashMap源码深度解析》一文中详细介绍过了，这里不再赘述。需要注意的是accessOrder参数，它决定了LinkedHashMap的顺序维持策略，当accessOrder=true时，采用访问顺序维持模式，而accessOrder=false时采用插入顺序维持模式。
public LinkedHashMap() {
super();
accessOrder = false;
}
可以看到LinkedHashMap无参构造器，将accessOrder属性设置为了false。
put方法
根据前面的描述知道了LinkedHashMap在插入Entry时会不断维持一个双向链表，那么我们有必要对put方法进行一些分析，需要注意的是LinkedHashMap并没实现自己的put方法，而是继承至HashMap的put方法。下面是HashMap中的put方法的源码：
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
/**
* 计算key的hash值，该hash算法调用了Obejct的hashcode
* 返回的是key.hashCode()&(key.hashCode()>>>16),其中>>>代表无符号右移
**/
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab;
Node<K,V> p;
int n, i;
//将Map内部的table数组赋给局部变量tab，如果table为空或者大小为0，则使用resize进行扩容
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
/**
* n-1&hash的效果就是 hash%n （因为HashMap中封装的数组的长度都是2的幂(默认16)）
* 如果数组对应位置没有元素（没有发生Hash冲突），则新建一个Node元素，放入该数组位置
*/
if ((p = tab[i = (n - 1) & hash]) == null)
// 重点******************************************
tab[i] = newNode(hash, key, value, null);
// 重点******************************************
/**
* 发生Hash冲突后的处理
*/
else {
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//如果此时解决Hash冲突的数据结构为链表，则遍历到链表尾部
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
//向链表中添加新元素
p.next = newNode(hash, key, value, null);
//如果新元素未加入之前，链表长度大于等于7了则需要将链表转换为红黑树了，换句话说加入新元素后链表长度大于等于8了，就转成红黑树。
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);//将链表转换为红黑树
//跳出循环
break;
}
//判断key是否相等
//这里的条件判断显示出HashMap允许一个key==null的键值对存储
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//如果找到了一个相同的key，则根据onlyIfAbsent判断是否需要替换旧的value。
//onlyIfAbsent为true时代表不替换原先元素。
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
//被修改的次数，fast-fail机制
++modCount;
//如果HashMap中存储的节点数量是否到达了扩容的阈值
if (++size > threshold)
//进行扩容
resize();
afterNodeInsertion(evict);
return null;
}
可能有人就糊涂了，既然是使用的父类的put方法，那么LinkedHashMap是如何维持双向链表的呢？实际上真正的玄机在第29行中，tab[i] = newNode(hash, key, value, null);掉用的是LinkedHashMap的newNode方法，就是在这个方法中实现了维持插入顺序的功能（不得不感叹设计的精妙）。
Node<K,V> newNode(int hash, K key, V value, Node<K,V> e) {
//创建Entry节点
LinkedHashMap.Entry<K,V> p = new LinkedHashMap.Entry<K,V>(hash, key, value, e);
//将新增节点放在链表尾部
linkNodeLast(p);
return p;
}
private void linkNodeLast(LinkedHashMap.Entry<K,V> p) {
LinkedHashMap.Entry<K,V> last = tail;
//将tail指针指向该元素（tail指针永远指向链表的尾部节点）
tail = p;
//原先的尾部节点若为空，则代表当前Map中没有存储数据，则将head指针也指向新增节点p
if (last == null)
head = p;
else {
//将before指针指向原先的队尾
p.before = last;
//将原先队尾的next指针指向新增元素
last.after = p;
}
}
get方法
前面我们提到了accessOrder属性，如果accessOrder=true就会使得LinkedHashMap维持访问顺序，一说到访问那就肯定是get方法了，我们就来看看它是如何维持访问顺序的。LinkedHashMap实现了自己的get方法：
public V get(Object key) {
Node<K,V> e;
if ((e = getNode(hash(key), key)) == null)
return null;
if (accessOrder)
//如果accessOrder为true则将访问的元素移到双向链表的尾部
afterNodeAccess(e);
return e.value;
}
void afterNodeAccess(Node<K,V> e) { // move node to last
LinkedHashMap.Entry<K,V> last;
// accessOrder=true且当前元素不处于链表的尾部
if (accessOrder && (last = tail) != e) {
LinkedHashMap.Entry<K,V> p = (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
// 因为马上要到链表尾部去了，所以要将当前元素的after指针置为空
p.after = null;
if (b == null)
//如果前一个节点为空，那么将头指针指向下一个节点
head = a;
else
//前一个节点不为空，那么将前一个节点的after指针指向下一个节点
b.after = a;
if (a != null)
//如果下一个节点不为空，则将下一个节点的before指针设为前一个节点
a.before = b;
else
//如果没有下一个节点，则将last指向前一个节点，实际上这一步正常情况下不会发生，因为前面已经验证了当前元素不是尾节点
last = b;
if (last == null)
head = p;
else {
//将当前元素插入链表尾部
p.before = last;
last.after = p;
}
//此时当前元素已经移到了链表尾部，将tail指针指向当前元素
tail = p;
//modeCount用于迭代器的快速失败机制（fail-fast）
++modCount;
}
}
LinkedHashMap用途浅析
我们在使用缓存的时候，需要采用特定的缓存淘汰机制，而LRU（Least Recently Used 最近最少使用）淘汰机制也是最常使用的。它会淘汰最久没有使用过的缓存，而借助LinkedHashMap可以非常容易的实现这一策略：
import java.util.LinkedHashMap;
import java.util.Map;
public class LRUCache<K, V> extends LinkedHashMap<K, V> {
private int maxEntries;
public LRUCache(int maxEntries) {
super(16, 0.75f, true);
this.maxEntries = maxEntries;
}
@Override
protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
return size() > maxEntries;
}
}
为什么重写父类的removeEldestEntry就能实现LRU策略呢？这仍然需要分析LinkedHashMap的源码，在该类中put方法（HashMap中的方法）会调用putVal()方法（HashMap的方法），而在putVal()方法的尾部会调用afterNodeInsertion()方法（LinkedHashMap中的方法），afterNodeInsertion方法就是淘汰策略的实现代码：
/**
* 可能移除最少使用的元素
**/
void afterNodeInsertion(boolean evict) {
LinkedHashMap.Entry<K,V> first;
//如果removeEldestEntry(first)返回true就会触发淘汰机制，淘汰的最久没有使用过的元素
if (evict && (first = head) != null && removeEldestEntry(first)) {
K key = first.key;
//删除双向链表的头节点
removeNode(hash(key), key, null, false, true);
}
}
