1. 前言

最近在慕课网挑一些视频学习的时候，刚好看到了LinkedHashMap来实现LRU，觉得还是一波比较秀的操作，特此记录一下。

2. Demo

LinkedHashMap的输出顺序有俩种：

• 插入顺序
• 访问顺序

2.1 插入顺序

插入顺序顾名思义，就是按照插入的顺序展示，比如：

    public static void main(String[] args) {

        LinkedHashMap<String, String> inserOrderMap = new LinkedHashMap<>();
        inserOrderMap.put("k1", "v1");
        inserOrderMap.put("k2", "v1");
        inserOrderMap.put("k3", "v1");
        inserOrderMap.put("k4", "v1");
        inserOrderMap.put("k5", "v1");
        inserOrderMap.put("k6", "v1");
        inserOrderMap.put("k7", "v1");
        inserOrderMap.put("k8", "v1");
        System.out.println(inserOrderMap);
}

结果：

{k1=v1, k2=v1, k3=v1, k4=v1, k5=v1, k6=v1, k7=v1, k8=v1}

可以看到，输出的顺序和插入的顺序是保持一致的

2.2 访问顺序

访问顺序，就是如果元素被访问（比如说通过get方法调用），那么该元素将被排序至最后：

    public static void main(String[] args) {
        LinkedHashMap<String, String> accessOrderMap = new LinkedHashMap<>(16,0.75F,true);
        accessOrderMap.put("k1", "v1");
        accessOrderMap.put("k2", "v1");
        accessOrderMap.put("k3", "v1");
        accessOrderMap.get("k2");
        System.out.println(accessOrderMap);
}

结果：

{k1=v1, k3=v1, k2=v1}

可以看到，这里在构造LinkedHashMap的时候，传入了三个构造参数：

• 16：初始容量
• 0.75F：扩容因子
• true：访问顺序，true代表访问顺序，false代表插入顺序

而代码中，我们首先依次插入k1、k2、k3，并且使用了k2，从结果可以看到，使用的k2元素被排到了最后

2.3 实现LRU

    public static void main(String[] args) {
        LruMap<String, String> lruMap = new LruMap<>(3);
        lruMap.put("k1","v1");
        lruMap.put("k2","v2");
        lruMap.put("k3","v3");

        lruMap.get("k1");
        lruMap.get("k2");
        lruMap.put("k4", "v4");
        System.out.println(lruMap);
    }

    private static class LruMap<K,V> extends LinkedHashMap {
        private int maxSize;
        LruMap(int maxSize) {
            super(16,0.75F, true);
            this.maxSize = maxSize;
        }

        @Override
        protected boolean removeEldestEntry(Map.Entry eldest) {
            return this.size() > maxSize;
        }
    }

结果：

{k1=v1, k2=v2, k4=v4}

思路主要如下：首先创建一个LruMap，底层为一个访问顺序的LinkeHashMap，并且指定了最大元素个数maxSize。之后重写removeEldestEntry方法，指定淘汰最老的元素（也就是最靠前的元素），淘汰策略为元素大小超过maxSize。由于LinkeHashMap指定为访问顺序，那么元素一旦被访问，就会被排到后面，自然不会被淘汰，这就符合LRU的思想了。

3. 源码

只知道表面的使用方法是不够的，还需要深入研究一下这骚操作的底层是如何实现的。

设想一下，当访问元素的时候，元素会被排到最后面，那么，调整顺序的操作应该是发生在get方法中，查看LinkedHashMap的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;
    }

可以看到，在获取到e之后，并且accessOrder为true的情况下（accessOrder便是构造LinkedHashMap的时候的第三个构造参数），调用了afterNodeAccess方法，查看afterNodeAccess方法：

    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;
        }
    }

逻辑有点复杂，但其作用就是将e节点调整为尾节点。

4. 总结

学了多年java，也是第一次知道LinkedHashMap还可以指定输出顺序，知识还是不够充足，还需要好好学习。