Android LruCache究竟是什么

A cache that holds strong references to a limited number of values. Each time a value is accessed, it is moved to the head of a queue. When a value is added to a full cache, the value at the end of that queue is evicted and may become eligible for garbage collection.

<p>If your cached values hold resources that need to be explicitly released, override {@link #entryRemoved}.

<p>If a cache miss should be computed on demand for the corresponding keys,override {@link #create}. 
This simplifies the calling code, allowing it to assume a value will always be returned, even when there‘s a cache miss.

    protected V create(K key) {
        return null;
    }

<p>This class does not allow null to be used as a key or value. 
A return value of null from {@link #get}, {@link #put} or {@link #remove} is unambiguous: the key was not in the cache.

public class LruCache<K, V> {
    private final LinkedHashMap<K, V> map;

    /** Size of this cache in units. Not necessarily the number of elements. */
    private int size;
    private int maxSize;

    private int putCount;
    private int createCount;
    private int evictionCount;
    private int hitCount;
    private int missCount;

    /**
     * @param maxSize for caches that do not override {@link #sizeOf}, this is
     *     the maximum number of entries in the cache. For all other caches,
     *     this is the maximum sum of the sizes of the entries in this cache.
     */
    public LruCache(int maxSize) {
        if (maxSize <= 0) {
            throw new IllegalArgumentException("maxSize <= 0");
        }
        this.maxSize = maxSize;
        this.map = new LinkedHashMap<K, V>(0, 0.75f, true);
    }
}