Java - LinkedHashMap原理分析
前言
Java中，Map类型的集合有很多种，我们之前分析过两种：
- Java - HashMap原理分析。最常用的一种。
- Java - ConcurrentHashMap原理分析。高并发、线性安全就用它，用它！
我们知道，HashMap关键就在于Hash。哈希值它并不能像数组那样是顺序的。因此我们插入的元素无法保证顺序性。因此，衍生出一个LinkedHashMap，本文就来讲解下它的原理。
一. LinkedHashMap原理
首先，LinkedHashMap 它是基于HashMap 的结构基础上创建的类。只不过在其基础上，有着双向链表的特性，并且元素的存储具有一定的顺序。
1.1 LinkedHashMap的结构
我们看下，
public class LinkedHashMap<K,V> extends HashMap<K,V> implements Map<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);
}
}
transient LinkedHashMap.Entry<K,V> head;
transient LinkedHashMap.Entry<K,V> tail;
final boolean accessOrder;
}
我们可以看到几个重要的成员变量：
Entry：用来实现双向链表的（也是和HashMap的一个不同点）。head：链表的头。tail：链表的尾。accessOrder：控制插入的顺序。
我们再来看下它的默认构造函数：
public LinkedHashMap() {
super();
accessOrder = false;
}
可以见到，super()，调用的就是HashMap的构造。除此之外，accessOrder的值赋值为false。
accessOrder的值决定着元素之间的顺序：
false（默认）：按照插入顺序排序。true：按照访问顺序排序（将当前元素移动至链表的末尾，即最后输出）。
我们这里来个例子，就可以更加直观的看这个顺序问题了：
按照插入顺序排序：
public static void main(String[] args) throws Exception {
LinkedHashMap<Integer, Integer> map = new LinkedHashMap<Integer, Integer>() {{
put(1, 1);
put(2, 2);
put(3, 3);
put(4, 4);
}};
for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
System.out.println(entry.getKey() + ", " + entry.getValue());
}
}
结果如下：
按照访问顺序排序：
public static void main(String[] args) throws Exception {
LinkedHashMap<Integer, Integer> map = new LinkedHashMap<Integer, Integer>(16, 0.75F, true) {{
put(1, 1);
put(2, 2);
put(3, 3);
put(4, 4);
}};
System.out.println("元素访问： " + map.get(3) + " 移动到链表末尾");
System.out.println("元素访问： " + map.get(1) + " 移动到链表末尾");
for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
System.out.println(entry.getKey() + ", " + entry.getValue());
}
}
结果如下：
那么接下来我们就从put函数开始看起，看看LinkedHashMap是如何维护顺序的。我们点入源码，我们可以发现，函数直接跳到了HashMap内部中的put函数，说明LinkedHashMap并没有重写put函数，而是直接调用父类HashMap的。
1.2 元素插入
因为在之前的文章中讲的比较详细了，我们直接把文章内容复制过来：
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.添加元素之前，先判断当前哈希桶数组的大小，是否是null或者空
if ((tab = table) == null || (n = tab.length) == 0)
// 如果是，那么需要将数组扩容，这样才能存储元素呀。
n = (tab = resize()).length;
// 2. (n - 1) & hash ：计算这个key对应的哈希桶下标
// 若此时对应的哈希桶中没有存储任何元素，即为null，就是没有发生碰撞，直接创建一个新的Node链表即可。
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
// 3.否则发生碰撞
Node<K,V> e; K k;
// 如果当前位置的数据，即链表的首节点，就是要找的，那么进行值的替换，
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
// 如果key不一样，那么就需要进行判断，判断当前节点是否是红黑树结构
else if (p instanceof TreeNode)
// 如果是，那么就需要根据红黑树的逻辑来添加一个新节点
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
// 如果不是红黑树，那么就是链表，遍历整个哈希冲突链，看看是否有重复的key
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;
}
// 如果找到了重复的key，就替换数据
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
// 如果找到的节点不是null，就将旧值替换为新值
if (e != null) {
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
// 插入完成之后，增加元素数量。判断是否需要扩容。
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
那么顺序控制的部分体现在哪呢？LinkedHashMap中的accessOrder变量也没用到呀？看过Java - HashMap原理分析这篇文章的同学可能发现到，上述源码中有两个函数并没有讲解到：
afterNodeAccess(e);
afterNodeInsertion(evict);
为什么没有讲这两个函数？因为在HashMap中，这两个函数没有什么实现：
但是！在LinkedHashMap中就有对应实现了，Java里面，如果子类重写了父类的方法，那么就会使用子类的函数去执行。
不仅如此，代码里还有一段代码隐藏的比较深：
tab[i] = newNode(hash, key, value, null);
实际上，newNode 在LinkedHashMap中也重写了！
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 = p;
// 如果没有头节点，那么当前节点就作为头结点即可
if (last == null)
head = p;
else {
// 否则将当前节点接到last的后面
p.before = last;
last.after = p;
}
}
1.2.1 afterNodeAccess 函数(将元素放到最后)
我们来看下源码：
// 将元素移动到最后
void afterNodeAccess(Node<K,V> e) {
LinkedHashMap.Entry<K,V> last;
// 如果accessOrder为true，即代表按照访问顺序来排序
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;
// 做双向链表的元素删除工作
p.after = null;
// 如果待删除节点没有前驱节点，代表他就是首节点，直接将后继节点作为首节点即可
if (b == null)
head = a;
else
// 前驱节点的next指针指向后驱节点。
b.after = a;
// 如果有后继节点，后直接点的前指针指向前驱节点
if (a != null)
a.before = b;
else
// 否则，同理，直接将前驱节点作为尾节点
last = b;
// 将当前待删除节点，放到尾部
if (last == null)
head = p;
else {
p.before = last;
last.after = p;
}
tail = p;
// 保证并发读，代表当前正在修改的元素数量
++modCount;
}
}
说白了一共就俩步骤：
- 将当前操作的元素，先从双向链表中剔除。
- 然后再将当前操作元素，放到双向链表的末尾。
1.2.2 afterNodeInsertion 函数(删除最老元素，LRU运用)
直接看源码：
// evict 代表为驱逐，即是否允许移除元素
void afterNodeInsertion(boolean evict) { // possibly remove eldest
LinkedHashMap.Entry<K,V> first;
// removeEldestEntry：判断是否满足移除最老节点
if (evict && (first = head) != null && removeEldestEntry(first)) {
K key = first.key;
// 删除对应的节点
removeNode(hash(key), key, null, false, true);
}
}
我们知道HashMap中，对于每个哈希槽中的链表，如果有新的元素进来，都是通过尾插法来插入到链表中的，即插入到链表的末尾。因此头结点就是这个哈希槽中最老的元素了。
但是removeEldestEntry实际上，它默认返回false，即说白了afterNodeInsertion这个函数它什么也不会干：
protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
return false;
}
既然默认的情况下，afterNodeInsertion并不会起到什么特殊作用，但是有些场景下，它就可以发挥了，比如：我们用LinkedHashMap去实现一个LRU算法。那么这个时候，我们就需要重写removeEldestEntry这个函数。
LRU算法，最少最近使用，如果保存的数据满了，我们需要将最近最少使用的数据给删除掉。那么如何用LinkedHashMap来实现呢？
- 首先，将
accessOrder这个变量设置为true。那么每次访问这个变量的时候，都会将这个变量放到链表的末尾。 - 那么这样一来链表的头部元素就是最久没用使用的那个元素了，当元素满的时候，我们就需要删除他。我们只需要让
removeEldestEntry在一定条件下返回true即可。
代码如下：
public 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);
}
public void put(int key, int value) {
super.put(key, value);
}
@Override
protected boolean removeEldestEntry(Map.Entry<Integer, Integer> eldest) {
return size() > capacity;
}
}
1.3 元素获取
同理，LinkedHashMap中的get函数，本质上还是使用的父类HashMap的函数，只不过稍微封装了下：
public V get(Object key) {
Node<K,V> e;
// 调用父类HashMap的函数，获取元素
if ((e = getNode(hash(key), key)) == null)
return null;
// 如果开启了按照访问顺序排序，那么还要维护下链表结构，让当前元素放到链表的末尾。
if (accessOrder)
afterNodeAccess(e);
return e.value;
}
1.4 元素删除
元素删除这块，还得看HashMap，它里面有个静态内部类HashIterator：
abstract class HashIterator {
public final void remove() {
Node<K,V> p = current;
// 理论上不可能删除null，是的抛出异常
if (p == null)
throw new IllegalStateException();
// 高并发下很容易造成这种情况，会抛出异常
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
current = null;
K key = p.key;
// 节点删除
removeNode(hash(key), key, null, false, false);
expectedModCount = modCount;
}
}
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;
// 只有table数组非空，才可以进行数组删除。并且对应的哈希槽节点不是null
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;
// 【第一部分】主要在做元素的查找操作。
// 如果哈希槽的首节点就是要找的，那么直接复制给node对象
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;
// 修改数+1
++modCount;
// 元素数量-1
--size;
afterNodeRemoval(node);
return node;
}
}
return null;
}
同样的，在HashMap中，afterNodeRemoval这个函数并没有具体的实现，LinkedHashMap同样对此进行了实现，因为LinkedHashMap中的链表是双向链表，因此还要多做几个操作去维护双向链表。主要是维护头尾节点。
我们看下源码：
void afterNodeRemoval(Node<K,V> e) {
// e是待删除元素，b前驱节点，a后继节点
LinkedHashMap.Entry<K,V> p =
(LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
// 先断开当前节点
p.before = p.after = null;
// 【维护after指针】
// 前驱节点是null，说明当前节点是头节点，直接赋值即可。
if (b == null)
head = a;
else
// 否则，修改前驱节点的next指针，跳过待删除节点，直接指向后继节点即可
b.after = a;
// 【维护before指针】
// 对链表尾的处理，若后继节点为null，说明当前节点是尾结点。直接赋值即可。
if (a == null)
tail = b;
else
// 同理，跳过待删除节点。
a.before = b;
}
二. 总结
1.LinkedHashMap的实现基于HashMap（继承关系），put/get/remove的底层都依赖于父类HashMap中的实现。
2.不同的是，LinkedHashMap中的节点是Entry而不再是Node节点。主要是因为LinkedHashMap中的链表是双向链表。而HashMap中的是单向链表。
3.LinkedHashMap中，对于put/get/remove的底层实现，比HashMap多了一些操作（只不过LinkedHashMap有具体的实现，而HashMap中没有）：
put：afterNodeAccess，将元素放到链表末尾。get：afterNodeAccess，将元素放到链表末尾。remove：afterNodeRemoval，维护双向链表的头尾节点。
4.同时LinkedHashMap多了一个accessOrder变量，用于控制链表的元素顺序：
true：按照访问顺序排序（包括插入操作）。false：默认的，按照插入顺序排序。
扫一扫
1464
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
