1、简介
LinkedHashMap
属于Map
的一种,而Map
是一种无序的key-value
集合,但总有例外的情况,LinkedHashMap
便是属于例外的其中一个,其最大的特点是可以保持插入元素的顺序。同时,可以编写一个类继承LinkedHashMap
,实现其中特定的方法,完成一个具有LRU特性的Map集合
继承结构图:
可以看到,LinkedHashMap
继承了HashMap
。它的内部有一个Entry
链表结构,可以保持插入节点的顺序,同时Entry
继承HashMap
中的Node
类(关于HashMap,可以看这一篇HashMap1.8),维护着Node
节点的相关特性。
其内部存储关系可从上图理解,其中红色箭头代表LinkedHashMap
维护的插入顺序,黑色箭头代表HashMap
原本的内部链表关系
2、底层结构
public class LinkedHashMap<K,V>
extends HashMap<K,V>
implements Map<K,V> {
//在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;
//lru开关,默认是fasle,设置为true可以实现lru
final boolean accessOrder;
}
主要是Entry
这个数据结构,在Node
的节点基础之上,增加了新的链表节点,维护插入关系
3、构造函数
public LinkedHashMap() {
super();
accessOrder = false;
}
public LinkedHashMap(Map<? extends K, ? extends V> m) {
super();
accessOrder = false;
putMapEntries(m, false);
}
//若是想实现lru,必须子类调用此构造函数
public LinkedHashMap(int initialCapacity,
float loadFactor,
boolean accessOrder) {
super(initialCapacity, loadFactor);
this.accessOrder = accessOrder;
}
4、添加元素
LinkedHashMap
添加元素使用的是HashMap
中的put方法
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 ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
...//省略
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
这里有两个方法需要注意,newNode
和afterNodeInsertion
。LinkedHashMap
中重写了这两个方法afterNodeInsertion
是实现LRU特性的方法之一
Node<K,V> newNode(int hash, K key, V value, Node<K,V> e) {
//创建Entry节点
LinkedHashMap.Entry<K,V> p =
new LinkedHashMap.Entry<>(hash, key, value, e);
//添加节点到链表尾部
linkNodeLast(p);
return 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;
}
}
newNode
方法把新创建的节点添加到链表尾部,链表中尾部节点表示当前链表最新的节点
//evict默认为true
void afterNodeInsertion(boolean evict) { // possibly remove eldest
LinkedHashMap.Entry<K,V> first;
//evict要为true,头结点不能为null,removeEldestEntry要返回true(默认为false)
if (evict && (first = head) != null && removeEldestEntry(first)) {
K key = first.key;
//删除节点
removeNode(hash(key), key, null, false, true);
}
}
//子类可以重写该方法,实现LRU特性
protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
return false;
}
5、查询元素
public V get(Object key) {
Node<K,V> e;
//调用HashMap中的get方法获取元素
if ((e = getNode(hash(key), key)) == null)
return null;
if (accessOrder)
//实现LRU特性的方法之一
afterNodeAccess(e);
return e.value;
}
LinkedHashMap
重写了HashMap
中的get方法,实际还是调用HashMap
中的方法获取元素。afterNodeAccess
是实现LRU特性方法之一,需要accessOrder
为true才行,只有在构造方法中才能指定其为true,默认是false
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;
}
上述代码主要干了一件事,将当前访问的元素,加入到LinkedHashMap
的链表尾部,而没有访问的数据,会逐渐移动到链表的头部
6、LRU demo
根据上面的分析,LinkedHashMap
查询时(accessOrder参数为true)会将查询到的元素移动到链表的尾部,或者插入节点时,将节点插入链表尾部,表明是当前最活跃的节点。链表的头结点,自然就是最不活跃的节点。而重写removeEldestEntry
方法,就可以实现LRU特性
public class demo {
public static void main(String[] args) {
LinkedHashMap<String, String> lru = new LinkedHashMap<>(16, 0.75f, true) {
@Override
protected boolean removeEldestEntry(Map.Entry<String, String> eldest) {
return size() > 3;
}
};
lru.put("1", "1");
lru.put("2", "2");
lru.put("3", "3");
lru.put("4", "4");
System.err.println(lru);
lru.get("2");
System.err.println(lru);
}
}
输出为
{2=2, 3=3, 4=4}
{3=3, 4=4, 2=2}
可以看出,最早加入的"1"并不在集合中,并且调用key=“2”,其移动到了链表尾部