起飞，手撸了一个 LRU 缓存，源码原来这么简单！

public class LinkedHashMap<K,V>
    extends HashMap<K,V>
    implements Map<K,V>{
    /**双向链表的头节点*/
    transient LinkedHashMap.Entry<K,V> head;
    /**双向链表的尾节点*/
    transient LinkedHashMap.Entry<K,V> tail;
    /**
      * 1、如果accessOrder为true的话，则会把访问过的元素放在链表后面，放置顺序是访问的顺序
      * 2、如果accessOrder为false的话，则按插入顺序来遍历
      */
      final boolean accessOrder;
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.

public static void main(String[] args) {
        //accessOrder默认为false
        Map<String, String> accessOrderFalse = new LinkedHashMap<>();
        accessOrderFalse.put("1","1");
        accessOrderFalse.put("2","2");
        accessOrderFalse.put("3","3");
        accessOrderFalse.put("4","4");
        System.out.println("acessOrderFalse："+accessOrderFalse.toString());

        //accessOrder设置为true
        Map<String, String> accessOrderTrue = new LinkedHashMap<>(16, 0.75f, true);
        accessOrderTrue.put("1","1");
        accessOrderTrue.put("2","2");
        accessOrderTrue.put("3","3");
        accessOrderTrue.put("4","4");
        accessOrderTrue.get("2");//获取键2
        accessOrderTrue.get("3");//获取键3
        System.out.println("accessOrderTrue："+accessOrderTrue.toString());
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.

acessOrderFalse：{1=1, 2=2, 3=3, 4=4}
accessOrderTrue：{1=1, 4=4, 2=2, 3=3}
1.
2.

public class LRULinkedHashMap<K, V> extends LinkedHashMap<K, V> {

    //创建一个容量为3的LinkedHashMap
    private static final int MAX_SIZE = 3;

    /**
     * 重写LinkedHashMap中removeEldestEntry方法
     * @param eldest
     * @return
     */
    protected boolean removeEldestEntry(Map.Entry eldest) {
        //如果容器中的元素个数大于MAX_SIZE，在每次添加元素的时候，移除容器中最近不被使用的元素
        return size() > MAX_SIZE;
    }

    public LRULinkedHashMap() {
        //设置LinkedHashMap初始化容量，负载因子为0.75f，accessOrder设置为true
        super(MAX_SIZE, 0.75f, true);
    }
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.

public static void main(String[] args) {
    LRULinkedHashMap<String,String> cache = new LRULinkedHashMap<String,String>();
    cache.put("1","a");
    cache.put("2","b");
    cache.put("3","c");
    System.out.println("初始cache内容：" + cache.toString());
    cache.get("2");
    System.out.println("查询key为2的元素之后，cache内容：" + cache.toString());
    cache.put("4","d");
    System.out.println("添加新的元素之后，cache内容：" + cache.toString());
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.

初始cache内容：{1=a, 2=b, 3=c}
查询key为2的元素之后，cache内容：{1=a, 3=c, 2=b}
添加新的元素之后，cache内容：{3=c, 2=b, 4=d}
1.
2.
3.