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模式时,访问过的结点会移动到链表的最后。
扫码关注公众号,浏览更多文章