LinkedHashMap源码分析
概述
该类继承了HashMap，所以它有HashMap的所有特性，在其内部以双向链表的形式维护数据，这样就维护了内部数据的有序性，即插入时的顺序就是迭代时的顺序。当设置了accessOrder访问模式时，对结构中的元素进行访问时，会始终将被访问的元素移动到链表的尾部，这种特性非常适合用于实现LRU绑在机制。
成员变量
// 双向链表的头部结点，也是最早添加到其内部的数据
transient LinkedHashMapEntry<K,V> head;
// 双向链表的尾部结点，最后添加到LinkedHashMap内部的数据
transient LinkedHashMapEntry<K,V> tail;
// 定义了两种访问模式，当为true时，和false两种模式，后继的代码分析中会看到两者的区别
final boolean accessOrder;
构造函数
// 给定初始容量和负载因子，将accessOrder初始化false
public LinkedHashMap(int initialCapacity, float loadFactor) {
super(initialCapacity, loadFactor);
accessOrder = false;
}
// 指定初始容量，负载因子将以默认值0.75进行初始化，accessOrder初始化false
public LinkedHashMap(int initialCapacity) {
super(initialCapacity);
accessOrder = false;
}
// 以默认容量16，默认负载因子0.75，进行初始化，accessOrder初始化false
public LinkedHashMap() {
super();
accessOrder = false;
}
// 以一个实现了Map接口的结构进行初始化，同时将accessOrder初始化false
public LinkedHashMap(Map<? extends K, ? extends V> m) {
super();
accessOrder = false;
putMapEntries(m, false);
}
// 同时指定初始容量，负载因子，和访问模式，有两模式：访问模式和插入模式
public LinkedHashMap(int initialCapacity,
float loadFactor,
boolean accessOrder) {
super(initialCapacity, loadFactor);
this.accessOrder = accessOrder;
}
LinkedHashMap定义了5个构造函数，主要是用来初始化三个重要变量，初始容量，负载因子，访问模式，前两个继承自HashMap，最后一个由自身维护，访问模式定义了在访问元素的时候要不要对访问元素进行移动操作，如果访问模式为true，访问某个元素，同时会将该元素结点移动到双向链表的尾部，这是因为LinkedHashMap有一个特性，就是添加到其内部的元素会按照添加顺序从表头排序到表尾，表尾的元素始终是新加的或最近访问过的。accessOrder这个变量就是维护了这样一个特性。
添加元素
LinkedHashMap没有重新实现添加方法，它仍然是调用父类HashMap的put方法进行添加，这里再将将HashMap中的put方法指出：这个方法的实现逻辑请参考：HashMap源码分析，高效的键值对存储结构
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);// 注意 1
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);// 注意 2
if (binCount >= TREEIFY_THRESHOLD - 1)
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
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;
}
在上面的注释的两处都调用了newNode方法，而LinkedHashMap则重载了这个方法，而在其树形化添加方法中也有一个newTreeNode方法在LinkedHashMap内部进行了重载，
Node<K,V> newNode(int hash, K key, V value, Node<K,V> e) {
// 关于LinkedHashMapEntry的分析，请后面出现
LinkedHashMapEntry<K,V> p =
new LinkedHashMapEntry<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的分析，也会后面出现
TreeNode<K,V> p = new TreeNode<K,V>(hash, key, value, next);
linkNodeLast(p);// 后面分析
return p;
}
LinkedHashMapEntry的定义如下，它继承了HashMap中定义的Node类，在其内部定义了两个变量before，after，指定当前结点的前一个结点和后一个结点，定义非常简单。
static class LinkedHashMapEntry<K,V> extends HashMap.Node<K,V> {
LinkedHashMapEntry<K,V> before, after;// 指定当前结点的前一个结点和后一个结点
LinkedHashMapEntry(int hash, K key, V value, Node<K,V> next) {
super(hash, key, value, next);
}
}
而TreeNode的实现，在这里也看一下，它是比较有意思的，它的父类竟然是LinkedHashMapEntry，这样HashMap.Node，LinkedHashMapEntry，TreeNode就建立了关系，它们依次被后者继承
// 注意TreeNode的父类
static final class TreeNode<K,V> extends LinkedHashMap.LinkedHashMapEntry<K,V> {
TreeNode<K,V> parent;
TreeNode<K,V> left;
TreeNode<K,V> right;
TreeNode<K,V> prev;
boolean red;
TreeNode(int hash, K key, V val, Node<K,V> next) {
super(hash, key, val, next);
}
}
回过头再看newNode，newTreeNode方法中的linkNodeLast方法：这个方法的做用是将新元素做为链表的尾结点，插入到双向链表中。调用了该方法，可以始终保证新元素会位于链表的尾部。
private void linkNodeLast(LinkedHashMapEntry<K,V> p) {
LinkedHashMapEntry<K,V> last = tail;
tail = p;// 将新元素做为表尾元素
if (last == null)// 如果原来的表尾为null，说明表中没有元素，此时表头引用也应该是null，此时将表头也设置为新元素
head = p;
else {// 如果原链表中有数据，则将新元素插入到链表尾部
p.before = last;
last.after = p;
}
}
删除元素
LinkedHashMap同样没有重载删除元素的方法，在HashMap的实现当中有一个空方法afterNodeRemoval，该方法在会在HashMap的removeNode方法最后移除结点的时候调用，而其在LinkedHashMap中实现如下：
void afterNodeRemoval(Node<K,V> e) {
// 找到当前删除结点的前驱结点和后继结点
LinkedHashMapEntry<K,V> p =
(LinkedHashMapEntry<K,V>)e, b = p.before, a = p.after;
p.before = p.after = null;// 将当前删除结点的前驱和后继设置为null，
if (b == null)// 如果当前删除结点的前驱结点为null，说明删除的结点是头部结点
head = a;// 这里将删除结点的后继结点设置为头结点
else
b.after = a;// 将删除结点的前驱的后继设置为删除结点的后继结点，也就是将当前结点从链表中断链，移出链表
if (a == null)// 如果后继结点是null，说明删除的是最后一个结点，将尾结点设置为当前删除结点的前驱
tail = b;
else
a.before = b;//如果不是最后一个结点，则将其前驱和后继相连
}
该方法的功能是将删除结点从链表中移出，然后使其前驱和后继相连接。这样将结点从链表中删除后，仍能保证链表的有序性。
获取元素
public V get(Object key) {
Node<K,V> e;
if ((e = getNode(hash(key), key)) == null)
return null;
if (accessOrder)// 在此处用到了访问模式，如果模式为true，会调用afterNodeAccess方法，此方法的功能是将结点移到到链表的最后，以说明结点刚刚被访问过。
afterNodeAccess(e);
return e.value;
}
// 将结点移到到链表的尾部
void afterNodeAccess(Node<K,V> e) {
LinkedHashMapEntry<K,V> last;
if (accessOrder && (last = tail) != e) {// 如果是访问模式，并且访问结点不是尾结点，这里需要将该结点移动到尾部
LinkedHashMapEntry<K,V> p =
(LinkedHashMapEntry<K,V>)e, b = p.before, a = p.after;//记录前驱和后继
p.after = null;// 当前访问结点后继置null
if (b == null)// 如果前驱结点为null，说明访问的结点是表头，这时将后续结点设置为头结点，这样当前访问的结点就从链表中移出
head = a;
else
b.after = a;// 否则将前驱的后继设置为后继结点，同样将当前访问结点从链表中移出
if (a != null)// 如果后继结点不为null，则将后续的前驱设置为前驱结点
a.before = b;
else
last = b;//否则删除结点是尾结点，将尾结点设置为前驱
// 上面的代码将访问结点先从链表中移出
// ===============================
// 下面代码将访问结点移动到链表尾部
if (last == null)// 如果此时尾结点为null，说明链表中已经没有数据,将访问结点设置为表头
head = p;
else {// 如果链尾不为null，将访问结点链接到链表尾
p.before = last;
last.after = p;
}
tail = p;// 链表尾设置为访问结点
++modCount;// 操作数加1
}
}
从afterNodeAccess的实现上看出，如果设置了访问模式为true，会将当前访问结点移动到尾部，说明此结点刚刚被访问过。
总结
- 拥有HashMap的所有特性
- 实现了双链表机制，因此比HashMap添加了一个有序性的特性。
- 当设置了accessOrder为true模式时，访问过的结点会移动到链表的最后。
扫码关注公众号，浏览更多文章
784
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
