本文基于JDK1.8
一、概述
1. 继承体系
HashMap 是 Java集合Collection的重要成员，如上图所示，也是Map家族中我们最为常用的一种。不过遗憾的是，HashMap是无序的，也就是说，迭代HashMap所得到的元素顺序并不是它们最初放置到HashMap的顺序。HashMap的这一缺点往往会造成诸多不便，因为在有些场景中，我们确需要用到一个可以保持插入顺序的Map。庆幸的是，JDK为我们解决了这个问题，它为HashMap提供了一个子类 —— LinkedHashMap。
2. 存储结构
虽然LinkedHashMap增加了时间和空间上的开销，但是它通过维护一个额外的双向链表保证了迭代顺序。特别地，该迭代顺序可以是插入顺序，也可以是访问顺序。因此，根据链表中元素的顺序可以将LinkedHashMap分为：保持插入顺序的LinkedHashMap 和 保持访问顺序的LinkedHashMap，其中LinkedHashMap的默认实现是按插入顺序排序的。
本质上，HashMap和双向链表合二为一即是LinkedHashMap。所谓LinkedHashMap，其落脚点在HashMap，因此更准确地说，它是一个将所有Entry节点链入一个双向链表双向链表的HashMap。在LinkedHashMapMap中，所有put进来的Entry都保存在如下面第一个图所示的哈希表中，但由于它又额外定义了一个以head为头结点的双向链表，因此对于每次put进来Entry，除了将其保存到哈希表中对应的位置上之外，还会将其插入到双向链表的尾部。
HashMap和双向链表的密切配合和分工合作造就了LinkedHashMap。特别需要注意的是，next用于维护HashMap各个桶中的Entry链，before、after用于维护LinkedHashMap的双向链表，虽然它们的作用对象都是Entry，但是各自分离，是两码事儿。
其中，HashMap与LinkedHashMap的Entry结构示意图如下图所示：
特别地，由于LinkedHashMap是HashMap的子类，所以LinkedHashMap自然会拥有HashMap的所有特性。比如，LinkedHashMap也最多只允许一条Entry的键为Null(多条会覆盖)，但允许多条Entry的值为Null。此外，LinkedHashMap 也是 Map 的一个非同步的实现。
此外，LinkedHashMap还可以用来实现LRU (Least recently used, 最近最少使用)算法。主要关键点是accessOrder属性，当这个属性为true时，会把get()操作之后的K-V键值对，放在LinkedHashMap双向链表的末尾，当put操作且map容量不够时，LinkedHashMap会自动删除双向链表 表头的键值对，从而完成LRU算法
二、源码解析
1. 属性
/**
* 双向链表头节点
*/
transient LinkedHashMap.Entry<K,V> head;
/**
* 双向链表尾节点
*/
transient LinkedHashMap.Entry<K,V> tail;
/**
* 迭代顺序。
* true代表按访问顺序迭代
* false代表按插入顺序迭代
*/
final boolean accessOrder;
LinkedHashMap.Entry 继承了HashMap的Node，并且每个entry都包含前指针和后指针，这是双向循环链表的特点。
/**
* LinkedHashMap的Entry继承了HashMap的Node
*/
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);
}
}
// HashMap的Node
// HashMap#Node
static class Node<K, V> implements Map.Entry<K, V> {
final int hash;
final K key;
V value;
Node<K, V> next;
}
accessOrder
是否需要按访问顺序排序，如果为false则按插入顺序存储元素，如果是true则按访问顺序存储元素，默认是false。
2. 构造方法
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);
}
public LinkedHashMap(int initialCapacity,
float loadFactor,
boolean accessOrder) {
super(initialCapacity, loadFactor);
this.accessOrder = accessOrder;
}
前四个构造方法accessOrder都等于false，说明双向链表是按插入顺序存储元素。
最后一个构造方法accessOrder从构造方法参数传入，如果传入true，则就实现了按访问顺序存储元素，这也是实现LRU缓存策略的关键。
3. 私有方法
linkNodeLast( LinkedHashMap.Entry<K,V> p)
/**
* 将指定entry插入到双向链表末尾
*/
private void linkNodeLast(LinkedHashMap.Entry<K,V> p) {
LinkedHashMap.Entry<K,V> last = tail;
//尾指针执行p
tail = p;
//如果旧的尾节点指向null，意味着双向循环链表为空，这时头尾指针都要指向p
if (last == null)
head = p;
else {//否则将p插入到旧尾节点的后面
p.before = last;
last.after = p;
}
}
transferLinks( LinkedHashMap.Entry<K,V> src, LinkedHashMap.Entry<K,V> dst)
// 将src替换为dst
private void transferLinks(LinkedHashMap.Entry<K,V> src,
LinkedHashMap.Entry<K,V> dst) {
LinkedHashMap.Entry<K,V> b = dst.before = src.before;
LinkedHashMap.Entry<K,V> a = dst.after = src.after;
//如果src的前指针指向null，说明src为头节点，这时将dst替换为头节点即可
if (b == null)
head = dst;
else//否则，将dst的前指针指向的节点的后指针指向dst
b.after = dst;
//如果src的后指针指向null，说明src为尾节点，这时将dst替换为尾节点即可
if (a == null)
tail = dst;
else//否则，将dst的后指针指向的节点的前指针指向dst
a.before = dst;
}
4. put(key, vlaue)方法
LinkedHashMap没有对 put(key,vlaue) 方法进行任何直接的修改，完全继承了HashMap的 put(Key,Value) 方法，HashMap#putput(Key,Value) 源码如下：
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);
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;
}
/**
* 几个构子方法，Hashmap中都是空方法，留给子类LinkedHashMap实现
*/
// Callbacks to allow LinkedHashMap post-actions
void afterNodeAccess(Node<K,V> p) { }
void afterNodeInsertion(boolean evict) { }
void afterNodeRemoval(Node<K,V> p) { }
LinkedHashMap#put 方法 继承于父类 HashMap，对于HashMap#put方法本身，LinkedHashMap没有再进行重写，所以基本操作与HashMap的大体骨架无异。但是LinkedHashMap比 HashMap多了一个双向链表，所以在put操作中 HashMap几个钩子方法，LinkedHashMap做了补充重写。
(1) afterNodeAccess(Node<K,V> e)
先看 afterNodeAccess(Node<K,V> e) 方法，如果迭代顺序accessOrder 为true，代表LinkedHashMap 的双向链表需要每次在put/get操作 之后 将 put/get 的Node节点放在LinkedHashMap双向链表 的 末尾，这样LRU算法起作用的时候，删除不常用的节点，从双向链表头节点开始删除，最近使用（put/get操作）的节点，则在双向链表的尾结点，最后才会被删除，符合算法使用。（注：LinkedHashMap双向链表默认不会删除，只是把最近常用的节点放在 双向链表的最后）
/**
* 若迭代顺序为true，且指定参数节点e不是尾结点，把指定参数节点e移到末尾
*/
void afterNodeAccess(Node<K,V> e) { // move node to last
LinkedHashMap.Entry<K,V> last;
//若迭代顺序为true，且指定参数节点e不是尾结点
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;
}
}
(2) afterNodeInsertion(boolean evict)
再看 afterNodeInsertion(boolean evict) 方法：
/**
* 可能把头节点删除
*/
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);
}
}
/**
* 如果map应该删除头节点，返回true
*
* 这个方法在被put和putAll方法被调用，当向map中插入一个新的entry时被执行。
* 这个方法提供了当一个新的entry被添加到linkedHashMap中，删除头节点的机会。
* 这个方法是很有用的，可以通过删除头节点来减少内存消耗，避免溢出。
*
* 简单的例子：这个方法的重写将map的最大值设为100，到100时，
* 每次增一个entry，就删除一次头节点。
*
* private static final int MAX_ENTRIES = 100;
* protected boolean removeEldestEntry(Map.Entry eldest) {
* //当map大小大于100时，返回true。意为允许删除头节点
* return size() > MAX_ENTRIES;
* }
*
* 这个方法一般不会直接修改map，而是通过返回true或者false来控制是否修改map。
* 这个方法仅仅返回false，这样头节点就永远都不会被删除了。
*
* @param eldest 头节点
* @return 如果map应该删除头节点就返回true，否则返回false
*/
protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
return false;
}
evict，驱逐的意思。
（1） 如果evict为true，且头节点不为空，且确定移除最老的元素，那么就调用HashMap.removeNode()把头节点移除（这里的头节点是双向链表的头节点，而不是某个桶中的第一个元素）；
（2） HashMap.removeNode()从HashMap中把这个节点移除之后，会调用afterNodeRemoval()方法；
（3） afterNodeRemoval()方法在LinkedHashMap中也有实现，用来在移除元素后修改双向链表，见下文；
（4） 默认removeEldestEntry()方法返回false，也就是不删除元素。
removeEldestEntry方法的实现，发现永远返回false。
这意味着afterNodeInsertion这个方法什么都做不了。那这个方法有什么用？
如果重写removeEldestEntry方法，就能定义是否删除的规则，afterNodeInsertion就有用了。
可以自己写个demo使用 LinkedHashMap实现LRU算法：
import java.util.LinkedHashMap;
import java.util.Map;
public class LRUTest {
public static void main(String[] args) {
LRU<Integer, Integer> lru = new LRU<>(4, 0.75f);
lru.put(1, 1);
lru.put(2, 2);
lru.put(3, 3);
lru.put(4, 4);
lru.put(5, 5);
lru.put(6, 6);
// 输出 lru: {3=3, 4=4, 5=5, 6=6}
System.out.println("lru: "+lru);
lru.get(4);
lru.put(3, 2333);
// 输出 lru: {5=5, 6=6, 4=4, 3=2333}
// 可以看到最旧的元素被删除了
// 且最近访问的3被移到了后面
System.out.println("lru: "+lru);
}
}
class LRU<K, V> extends LinkedHashMap<K, V> {
// 保存缓存的容量
private int capacity;
public LRU(int capacity, float loadFactor) {
super(capacity, loadFactor, true);
this.capacity = capacity;
}
/**
* 重写removeEldestEntry()方法设置何时移除旧元素
* @param eldest
* @return
*/
@Override
protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
// 当元素个数大于了缓存的容量, 就移除元素
return size() > this.capacity;
}
}
(3) afterNodeRemoval(Node<K,V> e)
在节点被删除之后调用的方法。
经典的把节点从双向链表中删除的方法。
void afterNodeRemoval(Node<K,V> e) { // unlink
LinkedHashMap.Entry<K,V> p =
(LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
// 把节点p从双向链表中删除。
p.before = p.after = null;
if (b == null)
head = a;
else
b.after = a;
if (a == null)
tail = b;
else
a.before = b;
}
4.get(Object key)方法
获取元素。
/**
* 返回指定的key对应的entry的value，如果entry为null或者value为null，则返回null
*
* @see #put(Object, Object)
*/
public V get(Object key) {
Node<K,V> e;
//如果key对应的entry为null，返回null
if ((e = getNode(hash(key), key)) == null)
return null;
//如果迭代顺序为按访问顺序迭代
if (accessOrder)
//将e插入双向链表末尾
afterNodeAccess(e);
//返回value
return e.value;
}
如果查找到了元素，且accessOrder为true，则调用afterNodeAccess()方法把访问的节点移到双向链表的末尾。
5. 其余重写HashMap的方法
reinitialize()
//将linkedHashMap重置到初始化的默认状态
void reinitialize() {
//重置哈希表
super.reinitialize();
//重置双向循环链表
head = tail = null;
}
newNode( int hash, K key, V value, Node<K,V> e)
/**
* 创建一个普通entry，将entry插入到双向循环链表的末尾,最后返回entry
*/
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);
//将entry插入到双向循环链表的末尾
linkNodeLast(p);
//返回entry
return p;
}
replacementNode( Node<K,V> p, Node<K,V> next)
/**
* 替换普通节点
*/
Node<K,V> replacementNode(Node<K,V> p, Node<K,V> next) {
LinkedHashMap.Entry<K,V> q = (LinkedHashMap.Entry<K,V>)p;
LinkedHashMap.Entry<K,V> t =
new LinkedHashMap.Entry<K,V>(q.hash, q.key, q.value, next);
transferLinks(q, t);
return t;
}
newTreeNode( int hash, K key, V value, Node<K,V> next)
/**
* 创建一个树的entry，将entry插入到双向循环链表的末尾,最后返回entry
*/
TreeNode<K,V> newTreeNode(int hash, K key, V value, Node<K,V> next) {
TreeNode<K,V> p = new TreeNode<K,V>(hash, key, value, next);
linkNodeLast(p);
return p;
}
replacementTreeNode( Node<K,V> p, Node<K,V> next)
/**
* 替换树节点
*/
TreeNode<K,V> replacementTreeNode(Node<K,V> p, Node<K,V> next) {
LinkedHashMap.Entry<K,V> q = (LinkedHashMap.Entry<K,V>)p;
TreeNode<K,V> t = new TreeNode<K,V>(q.hash, q.key, q.value, next);
transferLinks(q, t);
return t;
}
四、总结
HashMap与LinkedHashMap比较
不同点：
HashMap数据结构是数组+链表+红黑树，数据节点是无序的
LinkedHashMap数据结构是数组+链表+红黑树+双向列表，数据节点是有序的
相同点：
都是基于哈希表的实现。
存储的是键值对映射。
都继承了AbstractMap，实现了Map、Cloneable、Serializable。
它们的构造函数都一样。
默认的容量大小是16，默认的加载因子是0.75。
都允许key和value为null。
都是线程不安全的。
五、参考
Java 8 容器源码-LinkedHashMap：http://cmsblogs.com/?p=3965
Map 综述（二）：彻头彻尾理解 LinkedHashMap：https://blog.youkuaiyun.com/justloveyou_/article/details/71713781
扫一扫
1014
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
