LinkedHashMap继承了HashMap类,默认情况下使用entryset获取的集合顺序是与节点的插入顺序一致的。除去hashmap的逻辑之外,LinkedHashMap中还维护了一个双向链表,当新建待插入的Entry(LinkedHashMap中的Entry类继承了HashMap中的Node类)时,entry中新加了两个指针属性分别是before、after,分别指向之前和之后插入的节点。同时LinkedHashMap中多了3个参数,head、tail,accessOrder,双向链表默认是按照插入的顺序进行排列的,最先插入的节点(即最老的节点)为head,最新插入的节点为tail。accessOrder参数表示双向列表的排列顺序是按照节点的插入顺序还是访问顺序,默认是false即插入顺序,true代表的是访问顺序。在如下构造方法中我们可以指定访问模式。
public LinkedHashMap(int initialCapacity,
float loadFactor,
boolean accessOrder) {
super(initialCapacity, loadFactor);
this.accessOrder = accessOrder;
}
当排列模式是按访问顺序时,如果调用了get或put方法且key存在时,会调用afterNodeAccess方法,将最近被访问的节点移至双向队列的队尾。
下面说一下LinkedHashMap相对于HashMap重写了的部分:
1、LinkedHashMap并没有重写put方法,我们可以打开HashMap的put方法看一下,实际它调用了putval方法,在其中又分为待插入node的key已存在,待插入node的key在原map中不存在两种情况,不同情况执行完后对应的后续方法又不同,若key已存在则执行afterNodeAccess(node e)方法,key不存在则会使用newNode方法创建节点对象,插入后后会调用afterNodeInsertion(boolean evict),具体代码如下所示
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 ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null); //新建一个待插入节点
else {
/*中间的逻辑被我省略了*/
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e); //key已存在
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict); //key不存在,新插入node
return null;
}
void afterNodeAccess(Node<K,V> e) { // move node to last
LinkedHashMap.Entry<K,V> last;
if (accessOrder && (last = tail) != e) { //判断了accessOrder的值
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;
}
}
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);
}
}
//removeEldestEntery默认实现
protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
return false;
}
LinkedHashMap虽然没有重写put方法,但是它重写了afterNodeAccess和newNode、afterNodeInsertion方法,简单来说,在afterNodeAccess方法中会将最近访问到的节点移至双向队列的队尾,需要特别指出的是到默认情况下,若accessOrder为默认false(按插入顺序时),此时afterNodeAccess方法是不生效的,代码中有一个判断只有当accessOrder为true(按访问顺序展示)时才会将被访问的节点放到双向队列队尾;在newNode方法中会使用linkedNodeLast方法,将新创建的节点添加入双向队列的队尾;在afterNodeInsertion方法中会调用removeEldestEntry方法,若它返回为true则会把当前双向队列的head节点从map中删除掉,当然也会从双向队列删除该节点,但removeEldestEntry默认返回是false,因此在通常使用中afterNodeInsertion方法不生效。
2、LinkedHashMap重写了get方法,但它的get方法的主要逻辑于HashMap的相差不大,唯一的区别是get方法主逻辑后会调用afterNodeAccess方法,但还是那句话accessOrder为false时该方法不生效。
3、LinkedHashMap未重写remove方法,但是重写了其中的afterNodeRemove方法,在该方法中会将被删除节点从双向琏表中移除。
上面简单介绍了LinkedHashMap的实现,默认为按照插入顺序展示,当accessOrder为true按照访问顺序展示时,我们可以使用其实现简单的lru,最近最少使用算法,保持一个最近被使用的队列。被使用包括两种含义:最近被访问或最近刚插入,因此我们要使用的为访问模式。下面给出一个简单的代码,实现了一个lru,保存最近使用的n个节点
import java.util.LinkedHashMap;
import java.util.Map;
public class LRUCache extends LinkedHashMap<Integer, Integer> {
private int capacity;
public LRUCache(int capacity) {
super(capacity, 0.75f, true);
this.capacity = capacity;
}
public int get(int key) {
return containsKey(key) ? super.get(key) : -1;
}
public void put(int key, int value) {
super.put(key, value);
}
@Override
protected boolean removeEldestEntry(Map.Entry<Integer, Integer> eldest) {
return size() > capacity;
}
}