参考资料：
《LinkedHashMap》
写在开头：本文为个人学习笔记，内容比较随意，夹杂个人理解
目录
一、基础概念
1、基本属性
2、构造方法
二、继承HashMap的操作
1、查找
2、插入
3、删除
三、LinkedHashMap重写的方法
1、afterNodeAccess
2、afterNodeInsertion
3、afterNodeRemoval
补充
一、基础概念
LinkedHashMap继承自 HashMap，因此具有和 HashMap 一样的快速查找特性。
public class LinkedHashMap<K,V> extends HashMap<K,V> implements Map<K,V>1、基本属性
HashMap底层是数组 + 红黑树 + 链表，同时其是无序的，而 LinkedHashMap 刚好就比 HashMap多这一个功能，就是其提供有序的迭代策略。LinkedHashMap的有序可以按两种顺序排列，一种是按照插入的顺序，一种是按照读取的顺序（通过accessOrder来控制），而其内部是靠 建立一个双向链表来维护这个顺序的，在每次插入、删除后，都会调用一个函数来进行双向链表的维护 。
// 双链表的节点属性，包括前置节点befor与后置节点after
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);
}
}
// 双链表的头指针
transient LinkedHashMap.Entry<K,V> head;
// 双链表的尾指针
transient LinkedHashMap.Entry<K,V> tail;
// 用于控制双链表的迭代顺序：true 表示访问顺序；false 表示插入顺序
final boolean accessOrder;LinkedHashMap组成的链表结构如下图。
2、构造方法
// 默认构造方法
public LinkedHashMap() {
super();
accessOrder = false;
}
// 指定初始容量
public LinkedHashMap(int initialCapacity) {
super(initialCapacity);
accessOrder = false;
}
// 将别的Map转换成LinkedHashMap
public LinkedHashMap(Map<? extends K, ? extends V> m) {
super();
accessOrder = false;
putMapEntries(m, false);
}
// 指定初始化的容量与装载因子
public LinkedHashMap(int initialCapacity, float loadFactor) {
super(initialCapacity, loadFactor);
accessOrder = false;
}
// 指定初始化的容量与装载因子与迭代顺序
public LinkedHashMap(int initialCapacity,
float loadFactor,
boolean accessOrder) {
super(initialCapacity, loadFactor);
this.accessOrder = accessOrder;
}我们看到除了HashMap中带有的几个属性如initialCapacity、loadFactor等，还多了一个属性accessOrder，一般情况下为false，除非使用特定的构造方法指定为true。这个属性关系到了LinkedHashMap的迭代顺序，下面我们结合具体的成员方法来进行解析。
二、继承HashMap的操作
1、查找
LinkedHashMap实质上是调用的父类HashMap的getNode方法完成的查找操作，在完成查找后，再根据accessOrder判断是否调整双链表的结构，这个我们放到最后再解释。
public V get(Object key) {
Node<K,V> e;
// 调用父类HashMap中的查找方法getNode
if ((e = getNode(hash(key), key)) == null)
return null;
// 根据accessOrder判断是否调整双链表
if (accessOrder)
afterNodeAccess(e);
return e.value;
}
// HashMap中的getNode方法
// 如果是链表则执行链表的查找，如果已转换为红黑则按照树的结构去查找
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
if ((e = first.next) != null) {
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}2、插入
同样是调用的父类的put方法，前面是正常的插入操作，但是在最后步骤7，HashMap给我们预留了一个空方法afterNodeInsertion，在LinkedHashMap中正是通过重写该方法完成了自定义的迭代顺序。
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;
// 步骤1：tab为空则创建
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 步骤2：计算index，并对null做处理
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
// 步骤3：节点key存在，直接覆盖value
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
// 步骤4：判断该链为红黑树
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
// 步骤5：该链为链表
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
// 链表长度大于8转换为红黑树进行处理
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
// key已经存在直接覆盖value
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
// 步骤6：超过最大容量 就扩容
if (++size > threshold)
resize();
// 步骤7：留给子类重写的插入后操作
afterNodeInsertion(evict);
return null;
}注意这里的newNode和newTreeNode都在LinkedHashMap中被重写了，在新建节点后会将该节点插入到双链表的尾部。
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;
}
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;
}
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;
}
}3、删除
同样是调用的父类方法，且利用步骤9中预留给子类的afterNodeRemoval实现自定义迭代顺序。
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) {
// 步骤1：判断table是否为空
Node<K,V>[] tab; Node<K,V> p; int n, index;
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;
// 步骤2：如果p的hash值和key都与入参的相同, 则p即为目标节点
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
node = p;
// 步骤3：将p.next赋值给e，向下遍历节
else if ((e = p.next) != null) {
// 步骤4：如果p是TreeNode则调用红黑树的方法查找节点
if (p instanceof TreeNode)
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
else {
// 步骤5：按照普通链表节点的查找
do {
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
node = e;
break;
}
p = e;
} while ((e = e.next) != null);
}
}
// 步骤6：如果node不为空(即根据传入key和hash值查找到目标节点)，则进行移除操作
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) {
// 步骤7：如果是TreeNode则调用红黑树的移除方法
if (node instanceof TreeNode)
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
// 步骤8：按照普通链表进行节点删除
else if (node == p)
tab[index] = node.next;
else
p.next = node.next;
++modCount;
--size;
// 步骤9：留给子类重写的删除后操作
afterNodeRemoval(node);
return node;
}
}
return null;
}三、LinkedHashMap重写的方法
1、afterNodeAccess
在上文中，get方法在结束前，会根据accessOrder 是否为treu判断是否要调整双链表，如果accessOrder在初始化时被设置为了true，afterNodeAccess方法会在get方法被执行后，将被调访问的该节点调整至双链表的最后。
//在节点被访问后根据accessOrder判断是否需要调整链表顺序
void afterNodeAccess(Node<K,V> e) { // move node to last
// 用 last 表示插入 e 前的尾节点
// 插入 e 后 e 是尾节点, 所以也是表示 e 的前一个节点
LinkedHashMap.Entry<K,V> last;
//如果是访问序，且当前节点并不是尾节点
//将该节点置为双向链表的尾部
if (accessOrder && (last = tail) != e) {
// p: 当前节点
// b: 前一个节点
// a: 后一个节点
// 结构为: b <=> p <=> a
LinkedHashMap.Entry<K,V> p =
(LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
// 结构变成: b <=> p <- a
p.after = null;
// 如果当前节点 p 本身是头节点, 那么头结点要改成 a
if (b == null)
head = a;
// 如果 p 不是头尾节点, 把前后节点连接, 变成: b -> a
else
b.after = a;
// a 非空, 和 b 连接, 变成: b <- a
if (a != null)
a.before = b;
// 如果 a 为空, 说明 p 是尾节点, b 就是它的前一个节点, 符合 last 的定义
// 这个 else 没有意义，因为最开头if已经确保了p不是尾结点了，自然after不会是null
else
last = b;
// 如果这是空链表, p 改成头结点
if (last == null)
head = p;
// 否则把 p 插入到链表尾部
else {
p.before = last;
last.after = p;
}
tail = p;
++modCount;
}
}2、afterNodeInsertion
该方法在插入操作后，会根据removeEldestEntry判断是否删除双链表表头元素。在LinkedHashMap中，由于removeEldestEntry的返回值固定为false,因此这个方法并不会被启动，但是我们可以在子类中重写该方法。
// 插入新节点才会触发该方法，因为只有插入新节点才需要内存
// 根据 HashMap 的 putVal 方法, evict 一直是 true
// removeEldestEntry 方法表示移除规则, 在 LinkedHashMap 里一直返回 false
// 所以在 LinkedHashMap 里这个方法相当于什么都不做
void afterNodeInsertion(boolean evict) { // possibly remove eldest
LinkedHashMap.Entry<K,V> first;
// 根据条件判断是否移除最近最少被访问的节点
if (evict && (first = head) != null && removeEldestEntry(first)) {
K key = first.key;
removeNode(hash(key), key, null, false, true);
}
}
// 移除最近最少被访问条件之一，通过覆盖此方法可实现不同策略的缓存
// LinkedHashMap是默认返回false的，我们可以继承LinkedHashMap然后复写该方法即可
protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
return false;
}例如LRU算法中，我们规定链表只能存储固定数量的节点，因此在新增后我们需要删除最长时间没被访问过的节点（结合前文中的afterNodeAccess方法，每次访问该元素都会被调整至尾部），则需要重写removeEldestEntry方法，当节点超过限制时删除表头。
// LeetCode146. LRU 缓存
class LRUCache extends LinkedHashMap<Integer, Integer>{
private int capacity;
public LRUCache(int capacity) {
super(capacity, 0.75F, true);
this.capacity = capacity;
}
public int get(int key) {
return super.getOrDefault(key, -1);
}
@Override
protected boolean removeEldestEntry(Map.Entry<Integer, Integer> eldest) {
return size() > capacity;
}
}3、afterNodeRemoval
在删除元素之后，将元素从双向链表中删除。
//在节点删除后，维护链表，传入删除的节点
void afterNodeRemoval(Node<K,V> e) { // unlink
//p指向待删除元素，b执行前驱，a执行后驱
LinkedHashMap.Entry<K,V> p =
(LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
//这里执行双向链表删除p节点操作，很简单。
p.before = p.after = null;
if (b == null)
head = a;
else
b.after = a;
if (a == null)
tail = b;
else
a.before = b;
}补充
在LinkedHashMap重写的方法中，我们可以看出默认情况下（即accessOrder为false时）双向链表的顺序（即head至tail的顺序）即为节点的插入顺序，每次插入的节点都会按照尾插法加入到链表的尾部，因此双向链表的迭代顺序为插入顺序。
当我们将accessOrder修改为true时，每次访问的节点会被调整至链表尾部，这样，经过一段时间后链表头留下的就是最近最久未被访问的节点，链表迭代下来的顺序即为读取的顺序。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
