父类及实现的接口
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);
}
}
可以看到,源码中通过继承的方式给父类的结点类(Node)添加了两个属性,前驱与后继。这样才能形成链表。
而链表,可少不得表头,当然,有表尾就更好了,没有也无伤大雅,看需求,如果需要频繁用到表尾,那消耗一点空间给表尾自是大大地值。
/**
* The head (eldest) of the doubly linked list.
*/
transient LinkedHashMap.Entry<K,V> head;
/**
* The tail (youngest) of the doubly linked list.
*/
transient LinkedHashMap.Entry<K,V> tail;
可以看到在LinkedHashMap中添加了两个成员变量head和tail,也就是表头和表尾,transient关键字表示序列化时忽略这两个变量。
我们知道(单向)链表是有序的(从头到尾),那么这个内置的链表的顺序的什么呢?
关键的地方来了。
顺序
/**
* The iteration ordering method for this linked hash map: <tt>true</tt>
* for access-order, <tt>false</tt> for insertion-order.
*
* @serial
*/
final boolean accessOrder;
恩,这个变量就是关键。链表的结点顺序取决于这个变量,如果它为false,那么顺序取决于插入的顺序,即哪个结点先插入哪个在前(头在前),如果为false,则表示顺序取决于访问,什么意思呢?还请继续往下看。
accessOrder
找一找这个变量存在的地方。
第一处
public LinkedHashMap(int initialCapacity,
float loadFactor,
boolean accessOrder) {
super(initialCapacity, loadFactor);
this.accessOrder = accessOrder;
}
除了这个构造函数可以设置accessOrder,其它默认accessOrder为false。
第二处
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;
p.after = null;
if (b == null)
head = a;
else
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;
}
}
从代码可以看出,如果accessOrder为true(即链表结点顺序取决于访问时)将某个结点放到尾结点(如果它存在的话)后边并使它成为尾结点,那么这个结点是哪个结点呢?我们来找找调用了该方法的地方。
在LinkedHashMap中只找到这一处
public V get(Object key) {
Node<K,V> e;
if ((e = getNode(hash(key), key)) == null)
return null;
if (accessOrder)
afterNodeAccess(e);
return e.value;
}
/**
* {@inheritDoc}
*/
public V getOrDefault(Object key, V defaultValue) {
Node<K,V> e;
if ((e = getNode(hash(key), key)) == null)
return defaultValue;
if (accessOrder)
afterNodeAccess(e);
return e.value;
}
get的时候会调用(如果accessOrder为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);
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;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
public boolean replace(K key, V oldValue, V newValue) {
Node<K,V> e; V v;
if ((e = getNode(hash(key), key)) != null &&
((v = e.value) == oldValue || (v != null && v.equals(oldValue)))) {
e.value = newValue;
afterNodeAccess(e);
return true;
}
return false;
}
@Override
public V replace(K key, V value) {
Node<K,V> e;
if ((e = getNode(hash(key), key)) != null) {
V oldValue = e.value;
e.value = value;
afterNodeAccess(e);
return oldValue;
}
return null;
}
代码太多就不粘了,调用到它的方法除了之前找到的get方法之外还有replace,putVal,computeIfPresent,compute,merge这些方法。也就是说如果accessOrder为true,那么一个结点被访问到(比如get,put操作)时就会把它放到链表末尾去。
连接
还有一点要说的,插入的结点是怎么连到已有结点后面的?
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;
}
LinkedHashMap重写了父类HashMap的newNode方法,并对结点用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方法使结点与链表的尾结点相连接。