JAVA集合三Map—— 03LinkedHashMap
*特别声明：
*本文分析基于JDK8
*转载请注明源地址。
一、LinkedHashMap
LinkedHashMap 是一种有迭代顺序的HashMap。继承于HashMap,可以说是LinkedList和HashMap的结合体。
LinkedHashMap 定义的默认迭代顺序是按照插入的顺序来迭代，并且重复插入相同key，不会改变顺序。也可以通过设置accessOrder的值来改变顺序。设置为true，则表示按照存取顺序来迭代。其实存取的时候，如果设置为true会将当前节点放置在链表末尾,后面会看到源码。
accessOrder的定义：
/**
* 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;该字段可以通过3个参数的构造函数来设置。使用其他构造函数，则默认值为false。
public LinkedHashMap(int initialCapacity,
float loadFactor,
boolean accessOrder) {
super(initialCapacity, loadFactor);
this.accessOrder = accessOrder;
}
二、数据结构
LinkedHashMap的存储结构和HashMap一样，不同之处在于，LinkedHashMap通过加入了双向的链表结构来保存插入数据的顺序。所以说是LinkedList和HashMap的结合体。
为了保证迭代的顺序，LinkedHashMap存储了2份数据，一份是HashMap结构，一份是LinkedList的结构。迭代的时候使用LinkedList结构来迭代，保证顺序。
LinkedHashMap继承与HashMap，通过覆盖一些方法和加入链表结构来完成自己的功能。
首先定义了链表结构类似的head 和last，标识链表的开头和结尾，迭代的时候重头开始迭代。
/**
* 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;内部数据结构 Entry也加入了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);
}
}一切都和链表一样，关于链表LinkedList，可以看我的另一篇 LinkedList。
三、存取和顺序。
-
存储方法
LinkedHashMap没有覆盖存储put方法，调用的是HashMap的put方法（详细看>>>HashMap详解），这里主要分析LinkedHashMap在存储的时候，覆盖了哪些动作。
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
//初始化,put的时候初始化数组。
if ((tab = table) == null || (n = tab.length) == 0)
//初始化
n = (tab = resize()).length;
//计算hash值在数组中的index，如果该index不存在就创建newNode
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);//-----------------------------------1
else {
Node<K,V> e; K k;
//如果hash相同并且key也相同则覆盖数据
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//是否是treeNode,treeNode是1.8为了提高大容量Map的效率而加入的结构
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);------------------------2
//链表长度超过8 转换链表为红黑树进行存储
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;
}
}
//如果key存在则覆盖value返回oldValue
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);//----------------------------------------------3
return oldValue;
}
}
++modCount;
//是否需要扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);//-----------------------------------4
return null;
}主要来看看代码中标记的数字的含义，数字的地方是LinkedHashMap覆盖的地方。
覆盖newNode方法
1的位置是插入的key不存在是，创建一个节点。LinkedHashMap覆盖了该方法，创建node，并且将node放在链表结尾。
2的位置Hash冲突的时候，当然最后要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;
}
linkNodeLast(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;
}
}afterNodeAccess（）
3处是存在相同的key的时候，覆盖原来的Value，然后调用afterNodeAccess(），HashMap的该方法是一个空方法，LinkedList覆盖了它。该方法的作用是将节点移动到链表的末尾。该方法只会在存取的时候调用（put和get）。是否移动到末尾和设置的排序规则accessOrder有关。
void afterNodeAccess(Node<K,V> e) { // move node to last
LinkedHashMap.Entry<K,V> last;
//设置的排序规则有关。如果是按照插入顺序，则不会将第二次插入的相同key移到最后。
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
accessOrder定义的是迭代时节点的获取顺序。
accessOrder为fasle代表按照插入顺序，重复插入相同key不改变顺序。
accessOrder为true代表按照存取顺序，每次存取都会移动节点到末尾。
afterNodeInsertion
该方法是在插入之后执行，它到底做了些什么？
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);
}
}possibly remove eldest： 可能删除最旧的数据。
该方法主要是删除head，但是需要 removeEldestEntry返回true。但是LinkedHashMap的该方法返回的永远是false。
protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
return false;
}该方法的作用是判断什么时候需要我们删除node来减少内存。删除的节点是不怎么使用的节点。该方法需要我们自己覆盖实现（如果有必要）。
这里我们要引入一个概念：缓存淘汰算法(LRU)
缓存淘汰算法(LRU)
LRU（Least recently used，最近最少使用）算法根据数据的历史访问记录来进行淘汰数据，其核心思想是“如果数据最近被访问过，那么将来被访问的几率也更高”。在内存不足时可以淘汰最老的数据。
LinkedHashMap中，可以将最少访问的node放在head（这是可行的）。所以LinkedHashMap可以实现 LRU。
LRU详情，请查看LRU算法。
-
get方法
get方法 LinkedHashMap进行了覆盖，比较简单。加入了根据排序规则accessOrder的值来判断是否移动get的节点到链表的末尾。
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;
}
总结
1、 LinkedHashMap继承与HashMap，是HashMap和LinkedList的结合体。
2、内部结构entry 继承与HashMap.Entry,并且加入 before和After来支持链表操作。同时定义链表head和tail，用来实现链表的迭代。
3、默认的迭代顺序是插入顺序，重复插入不影响顺序。通过设置accessOrder=true可以将迭代顺序修改为存取顺序，每次存取，都会放在链表的末尾。改值只能通过构造方法设置。
4、LinkedHashMap可以实现LRU缓存淘汰算法，不过需要自己来实现。
如果对您有所帮助，请顶一下。
489
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
