写在前面
今天给大家带来的是LinkedHashMap源码分析，说起这个心中满满的痛。记得当初毕业的时候去面试，面试官问HashMap、LinkedHashMap、TreeMap哪些是有序的，我回答了HashMap是有序的。然后就让我回去等消息了，今天我就来谈谈自己对LinkedHashMap的理解，也希望能对大家有所帮助。
一、继承关系及主要字段
可以看到LinkedHashMap继承了HashMap，我前一篇HashMap的文章有提到有个参数是给LinkedHashMap使用的，这一点我后面会解释。
public class LinkedHashMap<K,V>
extends HashMap<K,V>
implements Map<K,V>
主要参数：
/**
* 这是linkedHashMap内部的数据结构Entry，它继承了HashMap的Node数据机构
*/
static class Entry<K,V> extends HashMap.Node<K,V> {
//可以看到他多了两个属性：一个是before后退指针，一个是after后退指针，所以它其实是一个双
//链表
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;
/**
* 是否按照访问顺序
*
* @serial
*/
final boolean accessOrder;
二、构造方法
/没什么特别的，指定初始容量和负载因子，调用父类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(Map<? extends K, ? extends V> m) {
super();
accessOrder = false;
putMapEntries(m, false);
}
//前几种构造方法accessOrder都初始化为false，这个构造方法可以自己指定，如果为true，排序将不
//再按照插入顺序，而是访问顺序
public LinkedHashMap(int initialCapacity,
float loadFactor,
boolean accessOrder) {
super(initialCapacity, loadFactor);
this.accessOrder = accessOrder;
}
三、put元素的过程以及排序原理
我们看代码会发现，LinkedHashMap并没有put方法，其实它用的是父类HashMap的put方法，关于父类put方法的详细介绍可以看我上一篇文章，这边不再做过多解释，那问题来了，父类插入节点是HashMap的Node类型，LinkedHashMap怎么把它变成自己的Entry类型呢？来看代码：
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)
//看这里：为什么HashMap不写成tab[i] = new Node()而是这样写？
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) {
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;
//节点访问后的钩子操作，模板方法 linkedHashMap实现
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
//节点插入后的钩子操作，也是模板方法 linkedHashMap实现
afterNodeInsertion(evict);
return null;
}
看一下newNode()方法：
// Create a regular (non-tree) node
Node<K,V> newNode(int hash, K key, V value, Node<K,V> next) {
//HashMap的实现是创建自己的Node节点
return new Node<>(hash, key, value, next);
}
但是我们发现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;
}
现在我们知道HashMap那么设计的原因：为了兼容子类，这种模板方法的设计模式我们也可以借鉴
好，接下来看一下这个linkNodeLast方法：
// link at the end of list
//看头上这行注释我们就知道采用的是尾插法
private void linkNodeLast(LinkedHashMap.Entry<K,V> p) {
//将tail节点赋值给last节点，注意，第一次插入的时候显然tail等于null
LinkedHashMap.Entry<K,V> last = tail;
//把新插入的节点p赋值给tail节点
tail = p;
//第一次插入时会走这个逻辑
if (last == null)
//把新插入的节点p赋值给head节点，如果是第一次插入，那么此时head=tail=p
head = p;
else {
//让p的后退指针指向last节点，也就是一开始的tail尾节点
p.before = last;
//让一开始的tail尾节点的前进指针指向p节点，至此就完成了新建的节点挂到了链表后面
last.after = p;
}
}
接着看一下上面提到的另外两个模版方法：
先看第一个：
void afterNodeAccess(Node<K,V> e) { // move node to last
LinkedHashMap.Entry<K,V> last;
//如果accessOrder为true并且当前被访问的节点不是尾节点
//因此如果构造函数没指定accssOrder为true的话都不会走这个逻辑
if (accessOrder && (last = tail) != e) {
//把e强转并赋值给p，然后把p的前一个节点赋值给b，p的下一个节点赋值给a
LinkedHashMap.Entry<K,V> p =
(LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
//让p的下一个节点置空
p.after = null;
//如果p的前一个节点等于空的话，证明他是头节点，要将p移到尾节点的话，只要将p的后一个节
//点设置为头节点，这样p就在链表之外了
if (b == null)
head = a;
else
//如果p的前一个节点不为空，那简单，只要将p前一个节点的前进指针指向p的下一个节点a
//这样就跳过了p
b.after = a;
//如果p的后一个节点不为空，就将p的后一个节点的后退指针指向p的前一个节点，因为是个双向
//链表，所以要这么做
if (a != null)
a.before = b;
//这里走的是p的后一个节点为空的情况，将p的前一个节点赋值给last
else
last = b;
//这里只有一种情况：p后置节点为空且p的前置节点为空也就是说只有一个节点
if (last == null)
//把p设置为head节点
head = p;
else {
//这里就是将p放到链表的最后，和last节点起个关联关系
p.before = last;
last.after = p;
}
//尾节点设置成当前p节点
tail = p;
++modCount;
}
}
我们看到如果插入元素过程没有覆盖已有元素，或者accessOrder没有设置为true，就不会触发这个排序。
来看下一个方法：
//这个方法对应元素插入之后但是没有覆盖原有值的操作
void afterNodeInsertion(boolean evict) { // possibly remove eldest
LinkedHashMap.Entry<K,V> first;
//这个方法永远不可能执行，因为removeEldestEntry这个方法永远返回false，
//它会留给子类去实现逻辑，推测可以作为最老的节点删除 做一个LRU Cache，可以参考mabatis的
//LRUCache实现
if (evict && (first = head) != null && removeEldestEntry(first)) {
K key = first.key;
removeNode(hash(key), key, null, false, true);
}
}
四、get方法相关
这个方法比较简单 ，不做过多解释了
public V get(Object key) {
Node<K,V> e;
//调用的是hashmap的getNode方法，不再做解释
if ((e = getNode(hash(key), key)) == null)
return null;
//多了一个访问控制的判断，如果为true则每次把被访问的元素放到链表尾
if (accessOrder)
afterNodeAccess(e);
return e.value;
}
五、如何迭代
首先我们知道HashMap的迭代是 HashMap.entrySet.iterator方法来获取迭代器，我们看源码不难发现，LinkedhashMap重写了entrySet方法：
public Set<Map.Entry<K,V>> entrySet() {
Set<Map.Entry<K,V>> es;
//new了一个LinkedentrySet对象
return (es = entrySet) == null ? (entrySet = new LinkedEntrySet()) : es;
}
来看一下LinkedEntrySet的代码：
//我们先看这一小段就够了，这个set是LinkedHashMap的内部类，他实现了iterator方法
final class LinkedEntrySet extends AbstractSet<Map.Entry<K,V>> {
public final int size() { return size; }
public final void clear() { LinkedHashMap.this.clear(); }
public final Iterator<Map.Entry<K,V>> iterator() {
//返回的是LinkedEntryIterator这个迭代器，这也是定义在内部的
return new LinkedEntryIterator();
}
public final boolean contains(Object o) {
if (!(o instanceof Map.Entry))
return false;
Map.Entry<?,?> e = (Map.Entry<?,?>) o;
Object key = e.getKey();
Node<K,V> candidate = getNode(hash(key), key);
return candidate != null && candidate.equals(e);
}
来看一下上面这个迭代器：
//来看一下这个迭代器，他的子类主要是
abstract class LinkedHashIterator {
//下一个节点
LinkedHashMap.Entry<K,V> next;
//当前节点
LinkedHashMap.Entry<K,V> current;
//期待的修改次数，这个和上一篇ArrayList的迭代器同理，不做过多介绍
int expectedModCount;
LinkedHashIterator() {
//首先将 head表头节点作为下一个节点
next = head;
//给定期待的修改次数
expectedModCount = modCount;
//当前节点为null
current = null;
}
public final boolean hasNext() {
//如果下一个节点不为空
return next != null;
}
//这个方法是next方法的实现，来看一下
final LinkedHashMap.Entry<K,V> nextNode() {
//把next节点保存到e，第一次进来时next节点是表头节点
LinkedHashMap.Entry<K,V> e = next;
//并发修改校验
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
//如果下一个元素是null，抛出异常
if (e == null)
throw new NoSuchElementException();
//把e节点设置为当前节点
current = e;
//next节点通过前进指针指向e的下一个节点
next = e.after;
return e;
}
public final void remove() {
Node<K,V> p = current;
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 class LinkedEntryIterator extends LinkedHashIterator
implements Iterator<Map.Entry<K,V>> {
//来看一下next（）方法的实现，他其实调用了父类的nextNode方法
public final Map.Entry<K,V> next() { return nextNode(); }
}
以上就是迭代的过程
写在最后
今天暂时先写到这里 ，因为我要睡觉了，有什么问题可以给我留言，不过相信看到这里，你对linkedHashMap的排序实现原理也有了一些自己的理解。如果觉得对自己有帮助的，可以给我点个赞或者关注我，以后会尽量日更。原创不易，转载请注明出处。