【Java集合类源码分析】LinkedHashMap源码分析
一、LinkedHashMap简介
LinkedHashMap是HashMap的一个子类，但它加入了一个双向链表的头结点，将插入的记录串成了一个双向循环链表，因此保存了记录的插入顺序，在用Iterator遍历LinkedHashMap时，取得的记录的顺序是插入次序或者是最近最少使用(LRU)次序。
public class LinkedHashMap<K,V>
extends HashMap<K,V>
implements Map<K,V> LinkedHashMap继承自HashMap并实现了Map接口。
二、LinkedHashMap内部结构
LinkedHashMap内部会在Map.Entry类的基础上，增加两个Entry类型的引用：before，after。LinkedHashMap使用一个双向循环链表，将其内部所有的Entry串起来。 
三、LinkedHashMap源码分析（JDK1.7）
public class LinkedHashMap<K,V>
extends HashMap<K,V>
implements Map<K,V>
{
private static final long serialVersionUID = 3801124242820219131L;
/**
* 双向循环链表的头结点
*/
private transient Entry<K,V> header;
/**
* 双向链表中元素排序规则的标志位
* true：按访问顺序排序
* false：按插入顺序排序
* @serial
*/
private final boolean accessOrder;
/**
* 构造一个具有指定初始容量和负载因子的空LinkedHashMap(按插入顺序排序)
* @param initialCapacity 初始容量
* @param loadFactor 加载因子
*/
public LinkedHashMap(int initialCapacity, float loadFactor) {
//调用HashMap的构造方法来构造底层数组
super(initialCapacity, loadFactor);
//链表中的元素默认按照插入顺序排序
accessOrder = false;
}
/**
* 构造一个具有指定的初始容量和默认负载因子（0.75）的空LinkedHashMap(按插入顺序排序)
* @param initialCapacity 初始容量
*/
public LinkedHashMap(int initialCapacity) {
super(initialCapacity);
accessOrder = false;
}
/**
* 构造一个具有默认初始容量（16）和默认负载因子（0.75）的空的LinkedHashMap(按插入顺序排序)
*/
public LinkedHashMap() {
super();
accessOrder = false;
}
/**
* 构造一个新的LinkedHashMap包含指定的map(按插入顺序排序)
*/
public LinkedHashMap(Map<? extends K, ? extends V> m) {
super(m);
accessOrder = false;
}
/**
* 构造一个具有指定初始容量，加载因子和排序模式的空的LinkedHashMap
*
* @param initialCapacity 初始容量
* @param loadFactor 加载因子
* @param accessOrder 排序规则
*/
public LinkedHashMap(int initialCapacity,
float loadFactor,
boolean accessOrder) {
super(initialCapacity, loadFactor);
this.accessOrder = accessOrder;
}
/**
* 覆写HashMap中的init方法(HashMap中该方法为空)
* 该方法在超类构造函数和伪构造函数（clone，readObject）插入元素前被调用
* 初始化一个空的双向循环链表，头结点中不保存数据，头结点的下一个结点才开始保存数据
*/
void init() {
header = new Entry<>(-1, null, null, null);
header.before = header.after = header;
}
/**
* 覆写HashMap中的transfer方法，它在父类的resize方法中被调用
* 扩容后将内部键值对重新映射到新的newTable中
* 覆写该方法的目的是提高复制的效率
* 利用双向循环链表的特点进行迭代，不用对底层的数组进行for循环
*/
void transfer(HashMap.Entry[] newTable) {
int newCapacity = newTable.length;
for (Entry<K,V> e = header.after; e != header; e = e.after) {
int index = indexFor(e.hash, newCapacity);
e.next = newTable[index];
newTable[index] = e;
}
}
/**
* 覆写HashMap中的containsValue方法
* 覆写该方法的目的同样是为了提高查询的效率
* 利用双向循环链表的特点进行迭代
*/
public boolean containsValue(Object value) {
// Overridden to take advantage of faster iterator
if (value==null) {
for (Entry e = header.after; e != header; e = e.after)
if (e.value==null)
return true;
} else {
for (Entry e = header.after; e != header; e = e.after)
if (value.equals(e.value))
return true;
}
return false;
}
/**
* 覆写HashMap中的get方法，通过getEntry方法获取Entry对象
* 注意recordAccess方法！！！
*/
public V get(Object key) {
Entry<K,V> e = (Entry<K,V>)getEntry(key);
if (e == null)
return null;
e.recordAccess(this);
return e.value;
}
/**
* 清空LinkedHashMap，并将双向链表还原为只有头结点的空链表
*/
public void clear() {
super.clear();
header.before = header.after = header;
}
/**
* 在Map.Entry类的基础上，增加两个Entry类型的引用：before，after
* 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);
}
/**
* 双向循环链表中，删除当前Entry
*/
private void remove() {
before.after = after;
after.before = before;
}
/**
* 双向循环链表中，将当前Entry插入到指定Entry前面
*/
private void addBefore(Entry<K,V> existingEntry) {
after = existingEntry;
before = existingEntry.before;
before.after = this;
after.before = this;
}
/**
* 覆写HashMap中的recordAccess方法（HashMap中该方法为空）
* 每当Map.get读取或Map.set修改预先存在的Entry时，超类将调用此方法
* 该方法提供了LRU算法(accessOrder=true)的实现，将最近使用的Entry放到双向循环链表的尾部
*/
void recordAccess(HashMap<K,V> m) {
LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;
//如果链表中元素按照访问顺序排序，则将当前访问的Entry移到双向循坏链表的尾部
//如果按照插入顺序排序，则不做任何事情
if (lm.accessOrder) {
lm.modCount++;
//移除当前访问的Entry
remove();
//将当前访问的Entry插入到链表的尾部
addBefore(lm.header);
}
}
void recordRemoval(HashMap<K,V> m) {
remove();
}
}
//迭代器
private abstract class LinkedHashIterator<T> implements Iterator<T> {
Entry<K,V> nextEntry = header.after;
Entry<K,V> lastReturned = null;
/**
* The modCount value that the iterator believes that the backing
* List should have. If this expectation is violated, the iterator
* has detected concurrent modification.
*/
int expectedModCount = modCount;
public boolean hasNext() {
return nextEntry != header;
}
public void remove() {
if (lastReturned == null)
throw new IllegalStateException();
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
LinkedHashMap.this.remove(lastReturned.key);
lastReturned = null;
expectedModCount = modCount;
}
Entry<K,V> nextEntry() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
if (nextEntry == header)
throw new NoSuchElementException();
Entry<K,V> e = lastReturned = nextEntry;
nextEntry = e.after;
return e;
}
}
//key迭代器
private class KeyIterator extends LinkedHashIterator<K> {
public K next() { return nextEntry().getKey(); }
}
//value迭代器
private class ValueIterator extends LinkedHashIterator<V> {
public V next() { return nextEntry().value; }
}
//Entry迭代器
private class EntryIterator extends LinkedHashIterator<Map.Entry<K,V>> {
public Map.Entry<K,V> next() { return nextEntry(); }
}
// These Overrides alter the behavior of superclass view iterator() methods
Iterator<K> newKeyIterator() { return new KeyIterator(); }
Iterator<V> newValueIterator() { return new ValueIterator(); }
Iterator<Map.Entry<K,V>> newEntryIterator() { return new EntryIterator(); }
/**
* 覆写HashMap中的addEntry方法
* 并没有覆写HashMap中的put方法，而是覆写了put方法所调用的addEntry方法和recordAccess方法
* put方法在插入的key已存在的情况下，会调用recordAccess方法
*/
void addEntry(int hash, K key, V value, int bucketIndex) {
createEntry(hash, key, value, bucketIndex);
// 双向链表的第一个有效结点（header后的第一个结点）为最近最少使用结点
Entry<K,V> eldest = header.after;
//如果有指示则删除最近最少使用的结点，否则在合适的情况下增加容量
//这要看对removeEldestEntry的覆写（默认是false不做任何处理）
if (removeEldestEntry(eldest)) {
removeEntryForKey(eldest.key);
} else {
if (size >= threshold)
resize(2 * table.length);
}
}
/**
* 覆写HashMap中的createEntry方法
* 与addEntry不同之处在于它不会调整表的大小或删除最近最少使用的结点。
*/
void createEntry(int hash, K key, V value, int bucketIndex) {
HashMap.Entry<K,V> old = table[bucketIndex];
Entry<K,V> e = new Entry<>(hash, key, value, old);
table[bucketIndex] = e;
//每次插入Entry时，都将其添加到双向链表的尾部
//这便会按照Entry插入LinkedHashMap的先后顺序来迭代元素
//新put进来的Entry是最近访问的Entry，放在双向链表的尾部，符合LRU算法的实现
e.addBefore(header);
size++;
}
/**
* 如果map应删除其最近最少访问的Entry，则返回true
* 在将新Entry插入map后，该方法由put和putAll方法调用
* 它为实施者提供一个添加新Entry时删除最老Entry的机会
* 如果map代表一个缓存，这是非常有用的：它允许map通过删除最近最少使用的Entry（header后的那个结点）来减少内存消耗。
* Sample use:
* private static final int MAX_ENTRIES = 100;
* protected boolean removeEldestEntry(Map.Entry eldest) {
* return size() > MAX_ENTRIES;
* }
* @return 如果需要删除最近最少使用的结点，则返回true，否则返回false
*/
protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
return false;
}
}四、LinkedHashMap的put()和get()
1、put()方法-向LinkedHashMap中存储键值对
/**
* HashMap中的put方法（LinkedHashMap并没有覆写该方法而是覆写了put方法所调用的addEntry方法和recordAccess方法）
*/
public V put(K key, V value) {
//若key为null,则将该键值对放置到table[0]，即第一个桶
if (key == null)
return putForNullKey(value);
//若key不为null，重新计算key的hashCode值
int hash = hash(key.hashCode());
//计算当前hashCode值确定应该将这一对键值对存放在哪一个桶中，即确定要存放桶的索引
int i = indexFor(hash, table.length);
//遍历所在桶中的Entry<K,V>链表，查找其中是否已经存在以key值为K存储的Entry<K,V>对象
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
//已存在,定位到对应的Entry<K,V>，其中的value值更新为新的value值,并返回旧值
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
//不存在，根据键值对<K,V>创建一个新的Entry<K,V>对象，然后添加到这个桶的链表头部
modCount++;
addEntry(hash, key, value, i);
return null;
}当要put进来的Entry的key在哈希表中已经存在的情况下，会覆盖旧value值并调用recordAccess方法，当该key不存在时，会调用addEntry方法将新的Entry插入到对应桶的单链表头部。
/**
* 覆写HashMap中的recordAccess方法（HashMap中该方法为空）
* 每当Map.get读取或Map.set修改预先存在的Entry时，超类将调用此方法
* 该方法提供了LRU算法(accessOrder=true)的实现，将最近使用的Entry放到双向循环链表的尾部
*/
void recordAccess(HashMap<K,V> m) {
LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;
//如果链表中元素按照访问顺序排序，则将当前访问的Entry移到双向循坏链表的尾部
//如果按照插入顺序排序，则不做任何事情
if (lm.accessOrder) {
lm.modCount++;
//移除当前访问的Entry
remove();
//将当前访问的Entry插入到链表的尾部
addBefore(lm.header);
}
}判断accessOrder是否为true，若为true，则将当前访问的Entry移动到双向循环链表的尾部，从而实现双向链表中的元素按照访问顺序来排序(最近访问的Entry放在双向循环链表的尾部，这样，前面就是最近未被访问的元素，实现了LRU算法)。
/**
* 覆写HashMap中的addEntry方法
*/
void addEntry(int hash, K key, V value, int bucketIndex) {
createEntry(hash, key, value, bucketIndex);
// 双向链表的第一个有效结点（header后的第一个结点）为最近最少使用结点
Entry<K,V> eldest = header.after;
//如果有指示则删除最近最少使用的结点，否则在合适的情况下增加容量
//这要看对removeEldestEntry的覆写（默认是false不做任何处理）
if (removeEldestEntry(eldest)) { //源码分析中对该方法已经做了详细讲解，这边不再重复
removeEntryForKey(eldest.key);
} else {
if (size >= threshold)
resize(2 * table.length);
}
}
/**
* 覆写HashMap中的createEntry方法
*/
void createEntry(int hash, K key, V value, int bucketIndex) {
//创建新Entry，并将其插入到对应桶的单链表头部，与HashMap相同
HashMap.Entry<K,V> old = table[bucketIndex];
Entry<K,V> e = new Entry<>(hash, key, value, old);
table[bucketIndex] = e;
//每次插入Entry时，都将其添加到双向链表的尾部
//这便会按照Entry插入LinkedHashMap的先后顺序来迭代元素
//新put进来的Entry是最近访问的Entry，放在双向链表的尾部，符合LRU算法的实现
e.addBefore(header);
size++;
}同样是将新Entry插入到table中对应桶所对应的单链表的头结点中，但在覆写后的createEntry中，将新Entry插入到了双向循环链表的尾部，从插入顺序层面来说，新Entry插入到双向循环链表的尾部，可以实现按照插入的先后顺序来迭代Entry，而从访问顺序层面来说，新Entry又是最近访问的Entry，也应该讲其放在双向循环链表的尾部。
2、get()方法-根据指定的key值从LinkedHashMap中取value值
/**
* 覆写HashMap中的get方法，通过getEntry方法获取Entry对象
* 注意recordAccess方法（上面已经做了讲解，这边不再重复）
* 若排序规则是按照插入的先后顺序，则什么也不做
* 若排序规则是按照访问的先后顺序，则将当前访问的Entry移到双向循环链表的尾部
*/
public V get(Object key) {
//调用HashMap中的getEntry方法
Entry<K,V> e = (Entry<K,V>)getEntry(key);
if (e == null)
return null;
e.recordAccess(this);
return e.value;
}
/**
* HashMap中的getEntry方法
*/
final Entry<K,V> getEntry(Object key) {
int hash = (key == null) ? 0 : hash(key.hashCode());
for (Entry<K,V> e = table[indexFor(hash, table.length)];
e != null;
e = e.next) {
Object k;
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
}
return null;
}五、总结
1、LinkedHashMap相较于HashMap又额外定义了一个以header为头结点的空的双向循坏链表，每次put进来Entry时，除了将其保存在哈希表中的对应的位置上外，还要讲其插入到这个双向循坏链表的尾部以维持内部Entry顺序。
2、LinkedHashMap继承自HashMap，除了遍历顺序外，其他特性与HashMap基本相同。
3、注意LinkedHashMap中的accessOrder标志位，当它为false时，表示双向循环链表中的元素按照Entry插入的先后顺序排序，即每次put新Entry时，将其插入到双向循环链表的尾部，这样在遍历这个链表时，Entry的输出顺序便和插入顺序一致，这也是LinkedHashMap默认的排序规则；当它为true时，表示双向循环链表中的元素按照访问的先后顺序排序，从源码中可以看到，put和get方法均有调用recordAccess方法（put方法在key已存在覆盖原来Entry的情况下调用），该方法判断accessOrder是否为true，若为true，则将当前访问的Entry(put进去的Entry或get出来的Entry)移到双向循环链表的尾部（key之前不存在时，即put新Entry时，会调用addEntry方法，它会调用createEntry方法，该方法同样将新Entry插入到了双向循环链表的尾部，既符合插入的先后顺序，又符合访问的先后顺序），否则，什么也不做。
4、LinkedHashMap是如何实现LRU的？首先，当accessOrder为true时，才会开启按访问顺序排序的模式，才能用来实现LRU算法。无论是put方法还是get方法，都会导致目标Entry成为最近访问的Entry，因此便把该Entry加入到了双向链表的末尾（get方法通过调用recordAccess方法来实现，put方法在覆盖已有key的情况下，也是通过调用recordAccess方法来实现，在插入新Entry时，则是通过createEntry中的addBefore方法来实现），这样便把最近使用了的Entry放入到了双向链表的后面，多次操作后，双向链表前面的Entry便是最近没有使用的，这样当结点个数满的时候，删除的最前面的Entry(head后面的那个Entry)便是最近最少使用的Entry。