众所周知，LinkedHashMap继承自HashMap，在原先的HashMap的基础上，它增加了Entry的双向链接。
有意思的是基于这种实现特性，LinkedHashMap 在迭代遍历时，取得键值对的顺序的依据是其插入次序或者是最近最少使用（LRU）的次序。
LRU算法根据数据的历史访问记录来淘汰数据，其核心思想是“如果数据最近被访问过，那么将来被访问的几率也更高”，从而实现在定量缓存空间下缓存内容的管理，常用于浏览器和移动端各应用等本地缓存管理。
通过access方式创建LinkedHashMap即可实现基本的LRU算法，可看源码中LinkedHashMap的构造函数：
/** * Constructs an empty <tt>LinkedHashMap</tt> instance with the * specified initial capacity, load factor and ordering mode. * * @param initialCapacity the initial capacity * @param loadFactor the load factor * @param accessOrder the ordering mode - <tt>true</tt> for * access-order, <tt>false</tt> for insertion-order * @throws IllegalArgumentException if the initial capacity is negative * or the load factor is nonpositive */ public LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder) { super(initialCapacity, loadFactor); this.accessOrder = accessOrder; }
查看源码可知，其中LinkedHashMap的取得键值对的顺序是由其构造函数中传入的第三个参数accessOrder决定，当其为false时，即为选用插入次序；为true时，即为选用LRU的次序。
而在我们利用LinkedHashMap实现LRU的关键在于重写下面这个方法
protected boolean removeEldestEntry(Map.Entry<K,V> eldest) { return false; }
下面我就使用LinkedHashMap实现LRU做了两个test。
第一个test的目的是为了验证LinkedHashMap实现LRU的可行性，即其根据访问时间来管理内部元素的排序，具体实现如下：
import java.util.Iterator; import java.util.LinkedHashMap; import java.util.Map; public class Test { public static void main(String[] args) { Map<Integer,Integer> map = new LinkedHashMap<>(16,0.75f,true); for(int i=0;i<16;i++) map.put(i, i); for(Iterator<Map.Entry<Integer, Integer>> iterator=map.entrySet().iterator();iterator.hasNext();) { System.out.print(iterator.next().getKey()+" "); } System.out.println(); map.get(5); for(Iterator<Map.Entry<Integer, Integer>> iterator=map.entrySet().iterator();iterator.hasNext();) { System.out.print(iterator.next().getKey()+" "); } } }
输出情况如下：
可见访问过的5确实被放到链表的末尾。
第二个test即是一个简单的实现LRU功能的LinkedHashMap,直接贴代码：
import java.util.Iterator; import java.util.LinkedHashMap; import java.util.Map; class LRULinkedHashMap<K,V> extends LinkedHashMap<K,V>{ private int capacity; private static final long serialVersionUID=1L; /** * LRULinkedHashMap的含参构造器 * @param capacity 指定的缓存最大容量 */ LRULinkedHashMap(int capacity){ super(16,0.75f,true); this.capacity=capacity; } @Override /** * 当map中存储元素大于了最大缓存容量时，删除链表顶端元素即最近最少使用元素。 * 输出当前最少使用的元素的键值对 */ protected boolean removeEldestEntry(java.util.Map.Entry<K, V> eldest) { // TODO 自动生成的方法存根 System.out.println("("+eldest.getKey()+"，"+eldest.getValue()+")"); return size()>capacity; } } public class LinkedHashMapForLRU { public static void main(String[] args) { Map<Integer, Integer> map = new LRULinkedHashMap<Integer,Integer>(5); //存入7个键值对 for(int i=0;i<7;i++) map.put(i, i); //输出最后保存在缓存中的键值对 for(Iterator<Map.Entry<Integer,Integer>> it = map.entrySet().iterator();it.hasNext();) { System.out.print(it.next().getKey()+" "); } } }
输出情况如下：
可见我们实现的LRULinkedHashMap确实发挥了它的作用。
那LinkedHashMap在源码中是怎么实现LRU算法的呢？
接下来从Map的初始化构造、put、get这三个方面结合源码展开
初始化构造函数：
初始化构造在前面已经提到过，这里直接贴上LinkedHashMap的几个构造函数
public LinkedHashMap() { super(); accessOrder = false; }
构造一个以插入顺序排序的空LinkedHashMap，，其默认初始容量为16，并且负载系数为0.75
public LinkedHashMap(int initialCapacity) { super(initialCapacity); accessOrder = false; }
构造一个以插入顺序排序的空LinkedHashMap，，其负载系数为0.75，根据传入的参数参数决定其初始容量
public LinkedHashMap(int initialCapacity, float loadFactor) { super(initialCapacity, loadFactor); accessOrder = false; }
构建一个以插入顺序排序的空LinkedHashMap，根据传入的参数决定其初始容量和负载系数。
public LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder) { super(initialCapacity, loadFactor); this.accessOrder = accessOrder; }
构建一个空LinkedHashMap，根据传入的参数决定其初始容量、负载系统及排序方式。
public LinkedHashMap(Map<? extends K, ? extends V> m) { super(); accessOrder = false; putMapEntries(m, false); }
而最后这种构造函数则是构建一个指定Map的LinkedHashMap，默认负载系统为0.75，而初始容量则足够容纳指定的Map。
Put：
通过查看源码发现LinkedHashMap并没有重写父类HashMap的put方法，下面我们先看一下HashMap的put方法。
public V put(K key, V value) { return putVal(hash(key), key, value, false, true); }
发现它调用了putVal(hash(key), key, value, false, true)，下面的即是其调用的putVal方法：
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 { Node<K,V> e; K k; if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) e = p; 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); 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; } } if (e != null) { // existing mapping for key V oldValue = e.value; if (!onlyIfAbsent || oldValue == null) e.value = value; afterNodeAccess(e); return oldValue; } } ++modCount; if (++size > threshold) resize(); afterNodeInsertion(evict); return null; }
其中调用了两个关键的方法
void afterNodeAccess(Node<K,V> p)和 void afterNodeInsertion(boolean evict)，而这两个方法实现关于插入节点和节点访问的细节，
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); } }
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; } }
从 if (evict && (first = head) != null && removeEldestEntry(first)) ，我们就能看到了调用了 removeEldestEntry(first)。即当该方法返回为真时，会调用方法来删除链表头。
而另一个重要的方法afterNodeAccess()则完成了在每一次节点访问后节点顺序的管理，想必这个方法会在get()方法中得到调用，下面我们就来看一下get()方法。
get()：
LinkedHashMap重写了get()方法和getOrDefault()方法。
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; }
public V getOrDefault(Object key, V defaultValue) { Node<K,V> e; if ((e = getNode(hash(key), key)) == null) return defaultValue; if (accessOrder) afterNodeAccess(e); return e.value; }
对比HashMap中的get()
public V get(Object key) { Node<K,V> e; return (e = getNode(hash(key), key)) == null ? null : e.value; }
这里添加了对accessOrder的判断，即当为LRU模式下，会调用afterNodeAccess();这个方法会管理链表的排序，将最近访问过的结点放到链表末尾。
到这里我们应该基本上理清了LinkedHashMap对LRU算法的支持的实现手段。
即通过构造函数中的accessOrder参数来选择建Map模式，通过 afterNodeAccess(Node<K,V> p)在结点被访问后的顺序管理，
afterNodeInsertion(boolean evict)方法实现结点插入后，根据removeEldestEntry(first)的返回结果来进行结点的删除操作。
后记：
当然直接继承LinkedHashMap来实现LRU，在多线程环境下极有可能会出现问题，因为LinkedHashMap不是一个线程安全的容器，所以如果我们想要基于这种容器实现并发环境下的LRU的话，需要增加线程同步的处理。
其中一种处理方式是调用Collections.synchronizedMap()。
而另外一种方法不通过继承来重写LinkedHashMap，而是通过组合的方式实现，并且对map的get()、put()、remove()、size()等操作进行加锁（synchronized），或者在此基础上进行同步上的优化。
