[Java源码分析]LinkedhashMap源码分析

LinkedHashMap是前面分析过的HashMap的子类，主要的作用就是在HashMap的基础上可以保证元素的插入顺序或访问顺序，内存访问算法中很经典的LRU算法就可以基于LinkedHashMap实现，在面试中也很常见。

一、基本参数与构造函数

//继承HashMap.Node，加入了before和after两个属性，用于表示双向链表中的前后结点
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;

// false: 基于插入顺序     true:  基于访问顺序
final boolean accessOrder;

/*
* 构造函数
*/

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，来设置LinkedHashMap是保证插入顺序还是访问顺序
public LinkedHashMap(int initialCapacity,
float loadFactor,
boolean accessOrder) {
super(initialCapacity, loadFactor);
this.accessOrder = accessOrder;
}

1、加入双向链表

可以看出，LinkedHashMap对结点加入了新的属性，before和after，用以表示形成双向链表。

同时加入了head和tail结点，表示双向链表的头结点和尾结点，通过链表头结点到尾结点的顺序来表示map中元素的插入顺序或访问顺序。

2、accessOrder

accessOrder是LinkedHashMap中一个关键的属性。

上面说到LinkedHashMap能够保存元素的插入顺序或者是访问顺序，就是通过accessOrder这一变量来决定的。

accessOrder默认为false，即保存插入顺序。

accessOrder为true时，保存访问顺序，其实访问顺序只是在插入顺序的基础上，在每次访问元素时，对链表顺序进行修改。

3、构造函数

从构造函数可以看出，LinkedHashMap的构造函数都是调用父类的，默认将accessOrder设置为false。

最后一个构造函数可以自己指定accessOrder。

二、put方法

下面来看一下map最常用的几个方法是如何实现的。首先还是put方法，看过源码才知道原来LinkedHashMap并没有重写父类的put方法，所以还是要再回到前面分析的HashMap的put方法中。

public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}

static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

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)
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;
}

以上代码是直接从上篇分析中粘下来的，去掉了所有的注释，又新加入了两个注释，这两个也是唯一与LinkedHashMap相关的地方。

1、newNode

LinkedHashMap与HashMap在map的存储方式上实现过程是一样的，区别在于LinkedHashMap需要通过双向链表来保存map的插入顺序，所以，区别之一就是新建的结点肯定不能是父类中原有的结点，所以LinkedHashMap重写了父类的newNode方法。

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;
}

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;
}
}

可以看出，在新建一个node之后，又调用了linkNodeLast方法，目的在于把这个新建的结点加入到双向链表的尾结点上，这样就保证了插入的顺序。

2、afterNodeInsertion方法

上面的put方法中第二个注释的地方，调用了afterNodeInsertion方法，

在父类HashMap中，afterNodeInsertion和其他两个方法并没有具体实现

// Callbacks to allow LinkedHashMap post-actions
void afterNodeAccess(Node<K,V> p) { }
void afterNodeInsertion(boolean evict) { }
void afterNodeRemoval(Node<K,V> p) { }

注释写的很明白，是为了LinkedHashMap准备的。方法名也很清楚，就是插入一个结点之后要做的事。下面是LinkedHashMap中重写的方法：

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;
}

正常来说，在插入结点的时候通过链表保存插入顺序，这就足够了，那么为什么还要调用这个方法呢，插入之后还有什么需要做的呢？

注释里面写了，这个方法可能的作用就是删除掉最老的元素，也就是离当前访问最远的元素。没错，这也是实现LRU时要重写的一个方法。下面的removeEldestEntry给出了判断的条件，重写时可以自由指定，比如当size大于指定的值后，就返回true。

public boolean removeEldestEntry(Map.Entry<Integer, Integer> eldest) {
return size() > capacity;
}

返回true后，就会删除掉head结点，也就是链表中的第一个结点。

三、get方法

与put方法不一样的是LinkedHashMap直接重写了get方法，原因在于在get的过程中需要判断accessOrder，这是子类的属性

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;
}

看一下父类的get方法

public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}

子类中并没有重写getNode方法，所以两个get方法唯一的区别就在于，子类在getNode之后会判断accessOrder，以判断是否调用afterNodeAccess方法。

也就是说，get方法正常来说是不会影响map的结构的也不会影响插入的顺序，但是这个操作会影响访问的顺序，所以如果accessOrder为true，那么在调用get方法之后，访问顺序就发生了变化，就需要调用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;
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;
}
}

afterNodeAccess做的很简单，当访问元素e之后，它就成了最新访问的，所以需要把它移动到链表的尾部。

四、remove方法

remove方法与put方法基本累死，子类都没有重写，再来看一下父类中的实现：

public V remove(Object key) {
Node<K,V> e;
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}

/*
* 实现Map.remove及相关方法
*/
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;
}

这也是从上篇分析中粘下来的，由于不用新建结点，所以remove方法只是在后面调用了afterNodeRemoval方法，这是唯一的区别

void afterNodeRemoval(Node<K,V> e) { // unlink
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
b.after = a;
if (a == null)
tail = b;
else
a.before = b;
}

afterNodeRemoval方法也很简单，就是更新删除的结点e的前后结点的指针，以保证链表的结构。

五、总结

1、了解HashMap之后再来看LinkedHashMap就会快很多。

2、两个类是父子关系，所以大部分实现方法都是相同的。

3、子类是父类的扩展，扩展的地方就是保证插入或访问的顺序，而扩展的方式就是通过加入一个双向链表来维持。

4、子类主要重写了几个可能会影响到插入或访问顺序的方法，比如put，get，remove

5、重写的方法主要就是加入了对链表的维护，

put方法，新建结点时指定前后结点，超过了某范围后可以进行删除

get方法在访问元素时更新链表结构来更新访问顺序

remove方法也是在删除结点后更新链表的结构