LinkedHashMap是HashMap的一个子类，它通过维护一个双向链表来保证元素的插入顺序或访问顺序。当accessOrder为true时，按照访问顺序排列，否则按照插入顺序。在插入元素时，它会将新节点添加到链表的尾部。删除节点时，会调整链表中的前后继节点。afterNodeAccess方法用于节点访问后的顺序调整。
目录
HashMap中元素插入时无序的，为了让遍历顺序和插入顺序一致，可以使用LinkedHashMap,其内部维护了一个双向链表来存储元素的顺序，并且可通过accessOrder属性控制遍历顺序为插入顺序或者访问顺序。本文基于JDK1.8对LinkedHashMap的内部实现原理分析。
1.类结构
LinkedHashMap类的层级结构图：
LinkedHashMap继承自HashMap,大部分方法都是直接使用HashMap的。主要成员遍历有：
//双向链表的头部节点(最早插入的节点)
transient LinkedHashMap.Entry<K,V> head;
//双向链表的尾部节点(最新插入的节点)
transient LinkedHashMap.Entry<K,V> tail;
//用于控制遍历顺序，为true时，按元素的插入顺序，为false时，按元素的访问顺序
final boolean accessOrder;LinkedHashMap继承自HashMap，内部存储数据的方式和HashMap一样，都是使用数组加链表(红黑树)的结构存储数据。
LinkedHashMap额外维护了一个双向链表，用于存储节点的属性，这个双向链表的数据类型为：LinkedHashMap.Entry<K,V>
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<K,V>继承自HashMap.Node类，新增了before和after属性，用于维护前继和后继节点，以此形成双向链表。
2.构造函数
LinkedHashMap的构造函数都是调用父类HashMap的构造函数进行初始化过程
public LinkedHashMap(int initialCapacity, float loadFactor) {
super(initialCapacity, loadFactor);
accessOrder = false;
}
public LinkedHashMap(int initialCapacity) {
super(initialCapacity);
accessOrder = false;
}
public LinkedHashMap() {
super();
accessOrder = false;
}
public LinkedHashMap(int initialCapacity,
float loadFactor,
boolean accessOrder) {
super(initialCapacity, loadFactor);
this.accessOrder = accessOrder;
}3. put(K key, V value)
LinkedHashMap并没有重写put(K key, V value)方法，直接使用HashMap的put(K key, V value)方法，那它是如何通过内部的双向链表维护元素顺序的？我们查看put(K key, V value)方法源码就能发现原因（因为put(K key, V value)源码在 JDK1.8 HashMap源码分析_leon7199的博客-优快云博客 一节中已经剖析过，所以下面我们只在和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;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
// 创建节点
tab[i] = newNode(hash, key, value, null);
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)
// 方法内部包含newTreeNode的操作
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
//创建节点
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
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;
if (++size > threshold)
resize();
//节点插入后续操作
afterNodeInsertion(evict);
return null;
}newNode()方法用于创建链表节点，LinkedHashMap重写了newNode()方法：
Node<K,V> newNode(int hash, K key, V value, Node<K,V> e) {
//创建一个LinkedHashMap.Entry实列
LinkedHashMap.Entry<K,V> p =
new LinkedHashMap.Entry<K,V>(hash, key, value, e);
//将新节点放入LinkedHashMap维护的双向链表的尾部
linkNodeLast(p);
return p;
}
private void linkNodeLast(LinkedHashMap.Entry<K,V> p) {
LinkedHashMap.Entry<K,V> last = tail;
//将新插入的节点赋值给双向链表尾部节点tail
tail = p;
if (last == null)
//last为null，说明双向链表为空，将当前节点赋值给双向链表的头节点
head = p;
else {
//否则，新插入的节点的before节点指向尾节点
p.before = last;
//尾节点的after节点指向当前节点
last.after = p;
}
}4.remove(Object key)
LinkedHashMap没有重写remove(Object key)方法，调用了HashMap的remove()方法：
public V remove(Object key) {
Node<K,V> e;
//被删除直接key的节点是否为null，是null，直接返回，否则返回删除节点的value值
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;
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;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
node = p;
else if ((e = p.next) != null) {
if (p instanceof TreeNode)
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
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);
}
}
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);
else if (node == p)
tab[index] = node.next;
else
p.next = node.next;
++modCount;
--size;
//节点删除后，执行后续操作
afterNodeRemoval(node);
return node;
}
}
return null;
}LinkedHashMap重写了afterNodeRemoval(Node<K,V> p)方法，删除节点后，会调用 afterNodeRemoval(Node<K,V> p)方法改变节点的前继节点和后继节点
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)
//如果当前节点的前置节点为null，说明当前节点是头节点，将当前节点的后继节点赋值给头节点head
head = a;
else
//否则，将前置节点的after指向后继节点
b.after = a;
if (a == null)
//如果后继节点为null，说明当前节点是尾部节点，被删除后，前置节点就是尾部节点了
tail = b;
else
//否则，将后继节点的before指向前置节点
a.before = b;
}通过该方法，我们就从LinkedHashMap的双向链表中删除了指定结点。
5.afterNodeAccess(Node<K,V> e)
afterNodeAccess(Node<K,V> e)就是节点被访问后执行的某些操作。LinkedHashMap重写了该方法：
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;
//将当前节点的后继节点置空
p.after = null;
if (b == null)
//当前节点的前置节点为空，说明当前节点是头节点，将头节点指向当前节点的后继节点 Node1->Node2,remove node1后，head=node2
head = a;
else
//否则，前置节点的后继节点指向 当前节点的后继节点 node1->node2->node3,remove node2,node1->node3
b.after = a;
if (a != null)
//如果当前节点的后继节点不为空，后继节点的前置节点指向 当前节点的前置节点 node1->node2->node3,remove node2, node3->node1
a.before = b;
else
//否则后继节点为空，说明当前节点为尾节点，有点多余，已经判断在表尾不操作((last = tail) != e)
last = b;
if (last == null)
//last == null,链表为空，head = p
head = p;
else {
//否则，p.before指向last，链表尾部，尾部.after指向p
p.before = last;
last.after = p;
}
//更新链表尾部节点
tail = p;
++modCount;
}
}
扫一扫
312
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
