概述
LinkedHashMap 继承自 HashMap，在 HashMap 基础上，通过维护一条双向链表，解决了 HashMap 不能随时保持遍历顺序和插入顺序一致的问题。LinkedHashMap的存储结构是HashMap的存储结构+双向链表，LinkedHashMap 对访问顺序也提供了相关支持，了解其工作原理必选先了解HashMap的工作原理。
数据结构
以上是LinkedHashMap大致的数据结构，红色的双向箭头表示链表的引用方向，LinkedHashMap在hashmap原有的Node节点上增加了before, after两个指向前后的节点，维护了一个双向链表。
看看类图
上面两张图展示LinkedHashMap 继承了HashMap，并且实现了Map接口。LinkedHashMap的操作单元是Entry，HashMap的操作单元是Node和TreeNode。
核心成员
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;
以上代码中Entry继承于HashMap.Node节点，在原有属性中增加了before用于指向前一个节点，after节点指向后一个节点。
HashMap中的三个后置方法
// Callbacks to allow LinkedHashMap post-actions
//访问节点后
void afterNodeAccess(Node<K,V> p) { }
//插入节点后
void afterNodeInsertion(boolean evict) { }
//删除节点后
void afterNodeRemoval(Node<K,V> p) { }
注释里面就说了这个几个方法是给LinkedHashMap重写的回调函数，上面几个方法后面会用。
构造方法
//这个构造方法直接调用了父类的构造方法
public LinkedHashMap(int initialCapacity, float loadFactor) {
super(initialCapacity, loadFactor);
accessOrder = false;
}
//初始大小
public LinkedHashMap(int initialCapacity) {
super(initialCapacity);
accessOrder = false;
}
//无参数构造函数
public LinkedHashMap() {
super();
accessOrder = false;
}
//initialCapacity 初始容量大小，使用无参构造方法时，此值默认是16
//loadFactor 加载因子，使用无参构造方法时，此值默认是 0.75f
//accessOrder false： 基于插入顺序 true： 基于访问顺序
public LinkedHashMap(int initialCapacity,
float loadFactor,
boolean accessOrder) {
super(initialCapacity, loadFactor);
this.accessOrder = accessOrder;
}
上面代码除了最后一个构造法是LinkedHashMap特有的，可以改变其遍历方式，其他的都是直接调用了父类的构造方法。
putVal方法
打开LinkedHashMap的源码发现并没有重写put方法，这里展示的还是HashMap的源码(这一段代码的逻辑可以去看上一篇)文章。
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)
//LinkedHashMap对newNode进行了重写
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)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
//LinkedHashMap对newNode进行了重写
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();
//节点插入后的回调函数，这个也是给LinkeadHashMap用的
afterNodeInsertion(evict);
return null;
}
既然是调用的HashMap的put方法，HashMap操作的是Node节点，LinkedHashMap操作的Entry节点，又没重写put方法。
那是什么时候换掉了操作的对象呢？
上面代码调用了一个newNode方法，有可能LinkedHashMap在这个位置动了手脚，于是找了找果然发现LinkedHashMap果然重写了newNode方法，在这个方法中将Node给换成了Entry（Entry继承于Node）。
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;
}
上面代码中还干了一件事儿，调用了linkNodeLast方法。
// link at the end of list
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;
}
}
可以看到linkNodeLast()方法是在节点创建后维护节点在双向链表中的处理。
绿色线条的节点代表新增的节点，红色线条代表需要删除的引用关系，蓝色线条代表新的节点引用关系。
大致情况就是将tail节点的after指向新的节点，新的节点after指向null，新的节点before指向tail节点。
三大后置处理器
插入节点后置处理
继续看putVal，在其最后调用了afterNodeInsertion方法，前面已经说了这个方法就是给LinkedHashMap重写的，直接上重写的代码。
//节点插入后进行回调的 通过put函数调用evict为true
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);//移除表头
}
}
protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
return false;
}
上面代码的第一个条件evict，这个参数从put->putVal->afterNodeInsertion过来，evict就是一个true了；第二个条件就是判断空，第三个条件就很重要了，默认返回了一个false，那就是留着给人重写的。上面代码大致的情况就是removeEldestEntry返回一个true的话，头结点就会被移除(后面的LRU和这里有关系)。
删除节点后置处理
LinkedHashMap的删除，也是直接使用的HashMap的删除方法，这里看看删除节点的最后的后置处理方法
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;
}
上面一大坨代码可以省略，直接看最后可以看到removeNode后面调用了afterNodeRemoval方法，下面代码的功能就是双向链表中移除某个元素
void afterNodeRemoval(Node<K,V> e) { // unlink
//a存储了被删除节点的前一个节点
//b存储了被删除节点的后一个节点
LinkedHashMap.Entry<K,V> p =
(LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
//将被删除的节点的前后置引用置空
p.before = p.after = null;
//如果被删除的是头节点,那么将头节点指向后面一个及节点
if (b == null)
head = a;
else
//如果前面不是null，代表不是头结点，那么把前面的一个的after指向后面一个节点
b.after = a;
//判断是不是尾部节点
if (a == null)
//将尾结点指向被删除的前面一个
tail = b;
else
//将before节点指向被删除的前一个
a.before = b;
}
红色线条和节点代表需要删除的节点，蓝色线条代码新的引用关系。
将节点2的after指向了节点4，将节点4的before指向了节点2，中间就删除了节点3
访问节点后置处理
LinkedHashMap是重写了HashMap的get方法的
public V get(Object key) {
Node<K,V> e;
//获取节点
if ((e = getNode(hash(key), key)) == null)
return null;
//前面提到了 true 使用最近被访问的顺序， false为插入顺序(默认顺序)
if (accessOrder)
afterNodeAccess(e);
return e.value;
}
以上代码get方法中可以看到只有accessOrder为true，即使用访问顺序时才会执行afterNodeAccess方法。接下来看afterNodeAccess方法做了什么事情。
void afterNodeAccess(Node<K,V> e) { // move node to last
LinkedHashMap.Entry<K,V> last;
//判断当前这个节点是不是最后一个，
if (accessOrder && (last = tail) != e) {
LinkedHashMap.Entry<K,V> p =
(LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
//因为要移动到链表尾部，所以将after设置为null
p.after = null;
//如果当前节点是头节点，将头节点指向当前节点的下一个节点
if (b == null)
head = a;
else
//将上一个节点的after指向当前节点的下一个节点
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;
}
}
上面代码就干了一件事儿，就是把这一次访问的这个节点，在双向链表中的位置移动到最后。
将原有节点2的前后引用关系删除，然后将这个节点移动到最后插入。
LRU算法实现
LRU，全称Least Recently Used最近最少使用，是一种内存淘汰算法。就是最近最少使用的数据将会被淘汰掉，核心思想就是我刚在访问了那么我认为我接下来还要访问你(更详细的百度一下)。
案例
下面假设我们需要缓存10条热点数据，就是最常访问的10条数据，利用LinkedHashMap实现如下
public class linkedHashMapLRU<K, V> extends LinkedHashMap<K, V> {
public linkedHashMapLRU() {
super(16, 0.75f, true);
}
protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
if (this.size() > 10)
return true;
return false;
}
public static void main(String[] args) {
linkedHashMapLRU<String, String> lru = new linkedHashMapLRU();
for (int i = 0; i < 50; i++) {
lru.put(String.valueOf(i), "111");
}
System.out.println("第一次顺序----");
lru.forEach((key, value) -> {
System.out.print(" " + key);
});
lru.get("45");
System.out.println("\n访问一次45后的顺序----");
lru.forEach((key, value) -> {
System.out.print(" "+key);
});
lru.put("50","11");
System.out.println("\n第插入50后的顺序----");
lru.forEach((key, value) -> {
System.out.print(" "+key);
});
}
}
程序运行结果
上面代码和结果可以看出
-
如果超过10个，超过10个就将前面的删除掉，只保留10个元素(插入后置方法中对头结点进行了删除)
-
将最近访问的一个数据放到最后(移动到最后)
-
将最近插入的数据放到最后(在newNode的时候将数据插入到了双向链表的尾部)
总结
-
HashMap基于hash散列算法实现的一个用于存储键值对数据的一种集合，其底层数据结构采用了数组+链表+红黑树来实现。其中对数组扩容来解决了hash分布不均匀问题，每次当前容量*加载因子时会触发扩容操作，扩容的长度是原来的一倍；使用链表解决hash冲突情况（链地址法），当某个链表长度达到了8且数组的长度达到了64,，这个时候使用了红黑树来保证hash冲突较高的情况下性能。
LinkedHashMap是一个继承于HashMap的集合，在HashMap的数据结构上增加了一个双向链表来保证数据的顺序性。重写了HashMap的newNode方法，在原有Node中增加了before和after两个属性来连接链表。并且HashMap中预留了插入后置，访问后置，删除后置三个后置处理方法让LinkedHashMap能够参与到Hash的流程中来维护链表。
PS：如果有不详细的地方或者有别的知识点想了解可以在评论区，我会的话可以分享分享
！
扫码关注，更多干货知识分享给你（如有错漏之处,敬请指正）
扫一扫
951
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
