LinkedHashMap LRU 实现

package lru;

import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;

/**
 * Created by sunyuming on 19/7/15.
 */
public class LRUMain {
    public static void main(String [] flag) {

        LRUCache<String, Integer> lruCache = new LRUCache<String,Integer>(10);

        for(int i=0; i<10; ++i) {
            System.out.println("put "+i);
            lruCache.put(String.valueOf(i), i);
        }

        for(int i=9; i>=0; --i) {
            System.out.println("get "+i);
            lruCache.get(String.valueOf(i));
        }

        // 触发
        System.out.println("put "+ "chufa");
        lruCache.put("chufa", 0);

        Iterator<Map.Entry<String, Integer>> iterator= lruCache.entrySet().iterator();

        while(iterator.hasNext())
        {
            Map.Entry entry = iterator.next();
            System.out.println(entry.getKey()+":"+entry.getValue());
        }

        for (Map.Entry<String, Integer> entry : lruCache.entrySet()) {
            System.out.println(entry.getKey()+":"+entry.getValue());
        }

        System.out.println();

    }

    private static class LRUCache<K, V> extends LinkedHashMap<K, V> {
        private int CACHE_SIZE;

        public LRUCache(int cashSize) {
            super(cashSize*2, 0.75f, true);
            CACHE_SIZE = cashSize;
        }

        @Override
        protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
            System.out.println("可能触发删除 - " + eldest.getKey()+":"+eldest.getValue());
            System.out.println("可能触发删除 - " + size() + "  " + CACHE_SIZE);
            if(size() > CACHE_SIZE) {
                System.out.println("触发删除 " + size() + "  " + CACHE_SIZE);
            }
            return size() > CACHE_SIZE;
        }
    }

}

输出：

put 0
可能触发删除 - 0:0
可能触发删除 - 1 10
put 1
可能触发删除 - 0:0
可能触发删除 - 2 10
put 2
可能触发删除 - 0:0
可能触发删除 - 3 10
put 3
可能触发删除 - 0:0
可能触发删除 - 4 10
put 4
可能触发删除 - 0:0
可能触发删除 - 5 10
put 5
可能触发删除 - 0:0
可能触发删除 - 6 10
put 6
可能触发删除 - 0:0
可能触发删除 - 7 10
put 7
可能触发删除 - 0:0
可能触发删除 - 8 10
put 8
可能触发删除 - 0:0
可能触发删除 - 9 10
put 9
可能触发删除 - 0:0
可能触发删除 - 10 10
get 9
get 8
get 7
get 6
get 5
get 4
get 3
get 2
get 1
get 0
put chufa
可能触发删除 - 9:9
可能触发删除 - 11 10
触发删除 11 10
8:8
7:7
6:6
5:5
4:4
3:3
2:2
1:1
0:0
chufa:0
8:8
7:7
6:6
5:5
4:4
3:3
2:2
1:1
0:0
chufa:0

证明：

1 每次put都会调用RemoveEldest～；

2 LinkedHashmap的迭代器与循环两种方式输出次序一样

3 在倒序循环读之前，“0”是第一个写入的，所以是最老的，在读之后，“9”是第一个被读的，所以是最老的，被干掉

2019.11.26

google's ConcurrentLinkedHashMap is developed as a multi-thread version of LinkedHashMap with LRU:https://blog.csdn.net/u011955252/article/details/80940373