图解LinkedHashMap原理
Posted 热爱编程的大忽悠
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了图解LinkedHashMap原理相关的知识，希望对你有一定的参考价值。
图解LinkedHashMap原理
1 前言
LinkedHashMap继承于HashMap，如果对HashMap原理还不清楚的同学，请先看上一篇：图解HashMap原理
2 LinkedHashMap使用与实现
先来一张LinkedHashMap的结构图，不要虚，看完文章再来看这个图，就秒懂了，先混个面熟：
2.1 应用场景
HashMap是无序的，当我们希望有顺序地去存储key-value时，就需要使用LinkedHashMap了。
Map<String, String> hashMap = new HashMap<String, String>();
hashMap.put("name1", "josan1");
hashMap.put("name2", "josan2");
hashMap.put("name3", "josan3");
Set<Entry<String, String>> set = hashMap.entrySet();
Iterator<Entry<String, String>> iterator = set.iterator();
while(iterator.hasNext())
Entry entry = iterator.next();
String key = (String) entry.getKey();
String value = (String) entry.getValue();
System.out.println("key:" + key + ",value:" + value);
我们是按照xxx1、xxx2、xxx3的顺序插入的，但是输出结果并不是按照顺序的。
同样的数据，我们再试试LinkedHashMap
Map<String, String> linkedHashMap = new LinkedHashMap<>();
linkedHashMap.put("name1", "josan1");
linkedHashMap.put("name2", "josan2");
linkedHashMap.put("name3", "josan3");
Set<Entry<String, String>> set = linkedHashMap.entrySet();
Iterator<Entry<String, String>> iterator = set.iterator();
while(iterator.hasNext())
Entry entry = iterator.next();
String key = (String) entry.getKey();
String value = (String) entry.getValue();
System.out.println("key:" + key + ",value:" + value);
结果可知，LinkedHashMap是有序的，且默认为插入顺序。
2.2 简单使用
跟HashMap一样，它也是提供了key-value的存储方式，并提供了put和get方法来进行数据存取。
LinkedHashMap<String, String> linkedHashMap = new LinkedHashMap<>();
linkedHashMap.put("name", "josan");
String name = linkedHashMap.get("name");
2.3 定义
LinkedHashMap继承了HashMap，所以它们有很多相似的地方。
public class LinkedHashMap<K,V>
extends HashMap<K,V>
implements Map<K,V>
2.4 构造方法
LinkedHashMap提供了多个构造方法，我们先看空参的构造方法。
public LinkedHashMap()
// 调用HashMap的构造方法，其实就是初始化Entry[] table
super();
// 这里是指是否基于访问排序，默认为false
accessOrder = false;
首先使用super调用了父类HashMap的构造方法，其实就是根据初始容量、负载因子去初始化Entry[] table，详细的看上一篇HashMap解析。
然后把accessOrder设置为false，这就跟存储的顺序有关了，LinkedHashMap存储数据是有序的，而且分为两种：插入顺序和访问顺序。
这里accessOrder设置为false，表示不是访问顺序而是插入顺序存储的，这也是默认值，表示LinkedHashMap中存储的顺序是按照调用put方法插入的顺序进行排序的。LinkedHashMap也提供了可以设置accessOrder的构造方法，我们来看看这种模式下，它的顺序有什么特点？
// 第三个参数用于指定accessOrder值
Map<String, String> linkedHashMap = new LinkedHashMap<>(16, 0.75f, true);
linkedHashMap.put("name1", "josan1");
linkedHashMap.put("name2", "josan2");
linkedHashMap.put("name3", "josan3");
System.out.println("开始时顺序：");
Set<Entry<String, String>> set = linkedHashMap.entrySet();
Iterator<Entry<String, String>> iterator = set.iterator();
while(iterator.hasNext())
Entry entry = iterator.next();
String key = (String) entry.getKey();
String value = (String) entry.getValue();
System.out.println("key:" + key + ",value:" + value);
System.out.println("通过get方法，导致key为name1对应的Entry到表尾");
linkedHashMap.get("name1");
Set<Entry<String, String>> set2 = linkedHashMap.entrySet();
Iterator<Entry<String, String>> iterator2 = set2.iterator();
while(iterator2.hasNext())
Entry entry = iterator2.next();
String key = (String) entry.getKey();
String value = (String) entry.getValue();
System.out.println("key:" + key + ",value:" + value);
因为调用了get(“name1”)导致了name1对应的Entry移动到了最后，这里只要知道LinkedHashMap有插入顺序和访问顺序两种就可以，后面会详细讲原理。
还记得，上一篇HashMap解析中提到，在HashMap的构造函数中，调用了init方法，而在HashMap中init方法是空实现，但LinkedHashMap重写了该方法，所以在LinkedHashMap的构造方法里，调用了自身的init方法，init的重写实现如下：
/**
* Called by superclass constructors and pseudoconstructors (clone,
* readObject) before any entries are inserted into the map. Initializes
* the chain.
*/
void init()
// 创建了一个hash=-1，key、value、next都为null的Entry
header = new Entry<>(-1, null, null, null);
// 让创建的Entry的before和after都指向自身，注意after不是之前提到的next
// 其实就是创建了一个只有头部节点的双向链表
header.before = header.after = header;
这好像跟我们上一篇HashMap提到的Entry有些不一样，HashMap中静态内部类Entry是这样定义的：
static class Entry<K,V> implements Map.Entry<K,V>
final K key;
V value;
Entry<K,V> next;
int hash;
没有before和after属性啊！原来，LinkedHashMap有自己的静态内部类Entry，它继承了HashMap.Entry，定义如下:
/**
* LinkedHashMap entry.
*/
private static class Entry<K,V> extends HashMap.Entry<K,V>
// These fields comprise the doubly linked list used for iteration.
Entry<K,V> before, after;
Entry(int hash, K key, V value, HashMap.Entry<K,V> next)
super(hash, key, value, next);
所以LinkedHashMap构造函数，主要就是调用HashMap构造函数初始化了一个Entry[] table，然后调用自身的init初始化了一个只有头结点的双向链表。完成了如下操作：
2.5 put方法
LinkedHashMap没有重写put方法，所以还是调用HashMap得到put方法，如下：
public V put(K key, V value)
// 对key为null的处理
if (key == null)
return putForNullKey(value);
// 计算hash
int hash = hash(key);
// 得到在table中的index
int i = indexFor(hash, table.length);
// 遍历table[index]，是否key已经存在，存在则替换，并返回旧值
for (Entry<K,V> e = table[i]; e != null; e = e.next)
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
modCount++;
// 如果key之前在table中不存在，则调用addEntry，LinkedHashMap重写了该方法
addEntry(hash, key, value, i);
return null;
我们看看LinkedHashMap的addEntry方法：
void addEntry(int hash, K key, V value, int bucketIndex)
// 调用父类的addEntry，增加一个Entry到HashMap中
super.addEntry(hash, key, value, bucketIndex);
// removeEldestEntry方法默认返回false，不用考虑
Entry<K,V> eldest = header.after;
if (removeEldestEntry(eldest))
removeEntryForKey(eldest.key);
这里调用了父类HashMap的addEntry方法，如下：
void addEntry(int hash, K key, V value, int bucketIndex)
// 扩容相关
if ((size >= threshold) && (null != table[bucketIndex]))
resize(2 * table.length);
hash = (null != key) ? hash(key) : 0;
bucketIndex = indexFor(hash, table.length);
// LinkedHashMap进行了重写
createEntry(hash, key, value, bucketIndex);
前面是扩容相关的代码，在上一篇HashMap解析中已经讲过了。这里主要看createEntry方法，LinkedHashMap进行了重写。
void createEntry(int hash, K key, V value, int bucketIndex)
HashMap.Entry<K,V> old = table[bucketIndex];
// e就是新创建了Entry，会加入到table[bucketIndex]的表头
Entry<K,V> e = new Entry<>(hash, key, value, old);
table[bucketIndex] = e;
// 把新创建的Entry，加入到双向链表中
e.addBefore(header);
size++;
我们来看看LinkedHashMap.Entry的addBefore方法：
private void addBefore(Entry<K,V> existingEntry)
after = existingEntry;
before = existingEntry.before;
before.after = this;
after.before = this;
从这里就可以看出，当put元素时，不但要把它加入到HashMap中去，还要加入到双向链表中，所以可以看出LinkedHashMap就是HashMap+双向链表，下面用图来表示逐步往LinkedHashMap中添加数据的过程，红色部分是双向链表，黑色部分是HashMap结构，header是一个Entry类型的双向链表表头，本身不存储数据。
首先是只加入一个元素Entry1，假设index为0：
当再加入一个元素Entry2，假设index为15：
当再加入一个元素Entry3, 假设index也是0：
以上，就是LinkedHashMap的put的所有过程了，总体来看，跟HashMap的put类似，只不过多了把新增的Entry加入到双向列表中。
2.6 扩容
在HashMap的put方法中，如果发现前元素个数超过了扩容阀值时，会调用resize方法，如下：
void resize(int newCapacity)
Entry[] oldTable = table;
int oldCapacity = oldTable.length;
if (oldCapacity == MAXIMUM_CAPACITY)
threshold = Integer.MAX_VALUE;
return;
Entry[] newTable = new Entry[newCapacity];
boolean oldAltHashing = useAltHashing;
useAltHashing |= sun.misc.VM.isBooted() &&
(newCapacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
boolean rehash = oldAltHashing ^ useAltHashing;
// 把旧table的数据迁移到新table
transfer(newTable, rehash);
table = newTable;
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
LinkedHashMap重写了transfer方法，数据的迁移，它的实现如下：
void transfer(HashMap.Entry[] newTable, boolean rehash)
// 扩容后的容量是之前的2倍
int newCapacity = newTable.length;
// 遍历双向链表，把所有双向链表中的Entry，重新就算hash，并加入到新的table中
for (Entry<K,V> e = header.after; e != header; e = e.after)
if (rehash)
e.hash = (e.key == null) ? 0 : hash(e.key);
int index = indexFor(e.hash, newCapacity);
e.next = newTable[index];
newTable[index] = e;
可以看出，LinkedHashMap扩容时，数据的再散列和HashMap是不一样的。
HashMap是先遍历旧table，再遍历旧table中每个元素的单向链表，取得Entry以后，重新计算hash值，然后存放到新table的对应位置。
LinkedHashMap是遍历的双向链表，取得每一个Entry，然后重新计算hash值，然后存放到新table的对应位置。
从遍历的效率来说，遍历双向链表的效率要高于遍历table，因为遍历双向链表是N次（N为元素个数）；而遍历table是N+table的空余个数（N为元素个数）。
2.7 双向链表的重排序
前面分析的，主要是当前LinkedHashMap中不存在当前key时，新增Entry的情况。当key如果已经存在时，则进行更新Entry的value。就是HashMap的put方法中的如下代码：
for (Entry<K,V> e = table[i]; e != null; e = e.next)
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
V oldValue = e.value;
e.value = value;
// 重排序
e.recordAccess(this);
return oldValue;
主要看e.recordAccess(this)，这个方法跟访问顺序有关，而HashMap是无序的，所以在HashMap.Entry的recordAccess方法是空实现，但是LinkedHashMap是有序的,LinkedHashMap.Entry对recordAccess方法进行了重写。
void recordAccess(HashMap<K,V> m)
LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;
// 如果LinkedHashMap的accessOrder为true，则进行重排序
// 比如前面提到LruCache中使用到的LinkedHashMap的accessOrder属性就为true
if (lm.accessOrder)
lm.modCount++以上是关于图解LinkedHashMap原理的主要内容，如果未能解决你的问题，请参考以下文章