LinkedHashMap、LRU
概述
LinkedHashMap继承于HashMap，在HashMap的基础上，新增了两个特性：
-
支持以节点的插入顺序来迭代该map内的所有节点；
-
支持缓存设计中LRU的特性，即LinkedHashMap支持按访问顺序来排序节点，具体在内部实现为如果开启了这个特性，则每次通过get方法访问了一个节点，则该节点会被移动到内部的双向链表的末尾，故双向链表的头结点是最近最少访问的节点，尾节点为刚刚访问过的节点，中间节点依次类推。
以上两个特性是互斥存在的，默认是以节点插入顺序来排序节点，可以通过设置构造函数中的accessOrder为true来开启按节点访问顺序排序。
-
以上两个特性都是基于在LinkedHashMap中额外维护了一个双向链表来实现。
-
以上两个特性都是在迭代器中体现，具体为entrySet方法，keySet方法，values方法，在for循环遍历这些方法返回的集合。
数据结构与核心字段
-
LinkedHashMap继承于HashMap，节点数据也是存储在HashMap的哈希表table数组中。
-
为了支持以上两个特性，在LinkedHashMap内部额外维护了一个双向链表的数据结构：对HashMap的节点Node进行了拓展，定义了双向链表的节点数据结构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);
}
}
transient LinkedHashMap.Entry<K,V> head; //双向链表的头结点
transient LinkedHashMap.Entry<K,V> tail; //双向链表的尾结点
-
注意LinkedHashMap在HashMap的哈希表table数组内的链表的链表数据存储节点，使用的是这个拓展的Entry类；而对于红黑树节点，则还是使用HashMap中定义的。
-
由于双向链表节点是LinkedHashMap额外的维护的结构，所以在增删改父类HashMap中的哈希表table数组中的数据节点时，需要回调LinkedHashMap中的对该双向链表增删改的方法来保持数据同步。
accessOrder：访问顺序排序开关
- 在LinkedHashMap中定义了accessOrder字段来控制是否以访问顺序排序双向链表的节点：默认为false，不使用，使用双向链表节点插入顺序来排序。
final boolean accessOrder;- accessOrder主要是在LinkedHashMap的get方法中使用，即在访问某个key对应的节点时，判断是否需要将在双向链表中对应的节点移动到双向链表末尾
结点的创建
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;
}
// 将该节点放到双向链表的末尾
// link at the end of list
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;
}
}
新增节点：newNode方法，覆盖HashMap的新增节点方法，返回的是LinkedHashMap内部定义的Entry节点，故在HashMap的哈希表table数组内部的链表的链表节点类型为Entry了。同时调用linkNodeLast方法将该节点放到内部的双向链表的末尾。
查找
public V get(Object key) {
Node<K,V> e;
// getNode为在HashMap中定义的方法
if ((e = getNode(hash(key), key)) == null)
return null;
// 判断是否以访问顺序排序双向链表节点
if (accessOrder)
afterNodeAccess(e);
return e.value;
}
// 将当前访问的节点，调整到双向链表的末尾，实现按访问顺序排序的功能
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;
}
}
访问节点：get方法，在内部调用了HashMap的getNode方法来从HashMap的哈希表table数组查找该指定key对应的节点。额外增加通过accessOrder的判断来决定是否对自身的双向链表节点进行调整。
public boolean containsValue(Object value) {
for (LinkedHashMap.Entry<K,V> e = head; e != null; e = e.after) {
V v = e.value;
if (v == value || (value != null && value.equals(v)))
return true;
}
return false;
}
containsValue（按值查找）：判断map中是否存在指定value的节点，重写了hashMap的containsValue方法，利用双向链表来查找。在HashMap中需要遍历哈希表table数组，然后遍历数组中每个元素对应的链表，即从链表头开始一个个比较。
插入
LinkedHashMap没有对put方法进行重写，即完全继承了HashMap的put方法，确定插入结点在双向链表中的位置通过重写newnode方法来做到
HashMap的增删改的回调方法
以上方法由于HashMap没有提供回调方法来进行拓展，故需要在LinkedHashMap中显式重写来加入对双向链表的操作。在HashMap中对于增删改节点对应了回调方法，故可以在LinkedHashMap中实现这些回调方法即可。
如下为在HashMap中声明的回调方法：
void afterNodeAccess(Node<K,V> p) { }
void afterNodeInsertion(boolean evict) { }
void afterNodeRemoval(Node<K,V> p) { }
- afterNodeAccess：节点访问回调，主要在get方法中调用，可以参见以上get方法的分析。
- afterNodeInsertion：节点插入回调，主要是在HashMap的putVal方法实现中最后调用，即在往HashMap的哈希表table数组插入数据相关查找完成后，最后调用afterNodeInsertion。LinkedHashMap的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内部会调用afterNodeRemoval方法来调整该双向链表
removeNode(hash(key), key, null, false, true);
}
}
主要用于在基于LinkedHashMap来实现缓存时，实现缓存的LRU特性使用。
- afterNodeRemoval：在HashMap删除某个节点时，回调afterNodeRemoval方法。LinkedHashMap的实现为在自身维护的双向链表中删除对应的链表节点：
// 在HashMap中的链表节点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.before = p.after = null;
if (b == null)
head = a;
else
b.after = a;
if (a == null)
tail = b;
else
a.before = b;
}
迭代器
在LinkedHashMap中，迭代器相关的操作是基于自身的双向链表，而不是父类HashMap的哈希表table数组来实现的，故迭代顺序是基于双向链表的顺序实现的，即以插入顺序（从前到后：最先插入->最后插入）排序或者访问顺序排序（从前到后：最近最少访问 -> 刚刚访问）。
LinkedHashMap的迭代器定义：主要在构造函数中将next初始化为双向链表的头结点head。
// Iterators
abstract class LinkedHashIterator {
LinkedHashMap.Entry<K,V> next;
LinkedHashMap.Entry<K,V> current;
int expectedModCount;
LinkedHashIterator() {
// 初始化为双向链表头结点head
next = head;
expectedModCount = modCount;
current = null;
}
public final boolean hasNext() {
return next != null;
}
final LinkedHashMap.Entry<K,V> nextNode() {
LinkedHashMap.Entry<K,V> e = next;
// 并发修改异常
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
if (e == null)
throw new NoSuchElementException();
current = e;
next = e.after;
return e;
}
public final void remove() {
Node<K,V> p = current;
if (p == null)
throw new IllegalStateException();
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
current = null;
K key = p.key;
removeNode(hash(key), key, null, false, false);
expectedModCount = modCount;
}
}
LRU缓存
由于LinkedHashMap支持按访问顺序排序双向链表的特性，故可以基LinkedHashMap来实现一个LRU缓存，具体为拓展LinkedHashMap，在缓存类中，重写removeEldestEntry方法来定义删除最近最少访问的节点的条件。
protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
return false;
}
由以上分析可知，removeEldestEntry主要是在HashMap的新增节点的回调afterNodeInsertion中调用。在LinkedHashMap的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内部会调用afterNodeRemoval方法来调整该双向链表
removeNode(hash(key), key, null, false, true);
}
}
- 在afterNodeInsertion中，head头结点就是最近最少访问的节点，故在该缓存类中，需要设置accessOrder为true来开启按访问顺序排序；
- 在afterNodeInsertion中会调用HashMap的removeNode方法来删除双向链表头结点head对应的哈希表table的链表的链表节点，在HashMap的removeNode会回调LinkedHashMap的afterNodeRemoval来删除LinkedHashMap内部的双向链表的链表节点；
- 故在继承了LinkedHashMap的缓存类只需实现removeEldestEntry方法即可：
public class LRU<K,V> extends LinkedHashMap<K, V> implements Map<K, V>{
private static final long serialVersionUID = 1L;
public LRU(int initialCapacity,
float loadFactor,
boolean accessOrder) {
super(initialCapacity, loadFactor, accessOrder);
}
/**
* @description 重写LinkedHashMap中的removeEldestEntry方法，当LRU中元素多余6个时，
* 删除最不经常使用的元素
* @author rico
* @created 2017年5月12日 上午11:32:51
* @param eldest
* @return
* @see java.util.LinkedHashMap#removeEldestEntry(java.util.Map.Entry)
*/
@Override
protected boolean removeEldestEntry(java.util.Map.Entry<K, V> eldest) {
// TODO Auto-generated method stub
if(size() > 6){
return true;
}
return false;
}
public static void main(String[] args) {
LRU<Character, Integer> lru = new LRU<Character, Integer>(
16, 0.75f, true);
String s = "abcdefghijkl";
for (int i = 0; i < s.length(); i++) {
lru.put(s.charAt(i), i);
}
System.out.println("LRU中key为h的Entry的值为： " + lru.get('h'));
System.out.println("LRU的大小 ：" + lru.size());
System.out.println("LRU ：" + lru);
}
}
总结
1 linkedhashmap在hashmap的数组加链表结构的基础上，将所有节点连成了一个双向链表。
2 当主动传入的accessOrder参数为false时, get方法使用时不会把元素放到双向链表尾部。
3 当主动传入的accessOrder参数为true时，使用put方法，当removeEldestEntry方法返回true时，直接删除最早元素以便新元素插入。如果没有冲突直接放入，同样加入到链表尾部。使用get方法时会把get到的元素放入双向链表尾部。
4 linkedhashmap的removeEldestEntry方法默认返回false，要实现lru很重要的一点就是集合满时要将最久未访问的元素删除，在linkedhashmap中这个元素就是头指针指向的元素。实现LRU可以直接实现继承linkedhashmap并重写removeEldestEntry方法来设置缓存大小。jdk中实现了LRUCache也可以直接使用。
465
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
