android LruCache使用

  LruCache能够实现内存缓存，对于一些需要的资源，每次都去文件中获取效率比较低，毕竟内存读取快很多。LruCache内部使用的算法叫最少使用算法，当缓存满时，会淘汰掉最近使用最少的缓存对象。LruCache通过LinkedHashMap实现，通过它将需要的对象留在内存中。
  LruCache是线程安全的。

---

分析一下它的代码:

  构造函数:

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

  maxSize表示最大缓存值，可以看到内部创建了一个LinkedHashMap，该Map输入输出都是有顺序的。

---

  put方法:

/**     * Caches {@code value} for {@code key}. The value is moved to the head of     * the queue.     *     * @return the previous value mapped by {@code key}.     */    public final V put(K key, V value) {        if (key == null || value == null) {            throw new NullPointerException("key == null || value == null");        }        V previous;        synchronized (this) {            putCount++;            size += safeSizeOf(key, value);            previous = map.put(key, value);            if (previous != null) {                size -= safeSizeOf(key, previous);            }        }        if (previous != null) {            entryRemoved(false, key, previous, value);        }        trimToSize(maxSize);        return previous;    }

  put方法将对象存放到缓存中，加了同步锁，保证线程安全，putCount表示添加到缓存中的数次数(该数不一定和缓存中有的对象个数相同)。size表示缓存大小。每次put后都要调用trimToSize()方法调整，判断缓存大小，如果缓存大小大于设定的最大值，不断删除缓存对象，直到缓存大小小于或等于设置的最大值。

---

  get方法:

public final V get(K key) {        if (key == null) {            throw new NullPointerException("key == null");        }        V mapValue;        synchronized (this) {            mapValue = map.get(key);            if (mapValue != null) {                hitCount++;                return mapValue;            }            missCount++;        }        /*         * Attempt to create a value. This may take a long time, and the map         * may be different when create() returns. If a conflicting value was         * added to the map while create() was working, we leave that value in         * the map and release the created value.         */        V createdValue = create(key);        if (createdValue == null) {            return null;        }        synchronized (this) {            createCount++;            mapValue = map.put(key, createdValue);            if (mapValue != null) {                // There was a conflict so undo that last put                map.put(key, mapValue);            } else {                size += safeSizeOf(key, createdValue);            }        }        if (mapValue != null) {            entryRemoved(false, key, createdValue, mapValue);            return mapValue;        } else {            trimToSize(maxSize);            return createdValue;        }    }

  同样从缓存中获取数据的时候也加了同步锁，如果从缓存中对象存在，那么hitCount++，hitCount表示正确获取到对象的次数。不然missCount++，missCount表示丢失的次数，可能该对象由于缓存满了，从缓存中删去了，也可能该对象未加入过缓存。 那我们就要把当前值存入缓存。这里有一个create()方法，如果当前未得到数据，可以重写该方法，指定当前key值对应的对象。 之后会将该key和指定的值存入map中，如果map中之前存在该key值，就重新将之前的value值存入map中，而不是create()方法指定的值； 不然就是将key值和create()指定的值存入map中，size加上指定值的大小。最后调整缓存值。

---

  sizeof()方法:
需要重写该方法，该方法返回存入的对象的数据大小。

  这是几个比较重要的方法，其它方法实现都是类似的，可以自己分析。

---

LruCache使用:

int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);        int cacheSize = maxMemory / 8;        mMemoryCache = new LruCache<String, Bitmap>(cacheSize) {            @Override            protected int sizeOf(String key, Bitmap value) {                return value.getHeight() * value.getRowBytes();            }        };

  一般初始化给定缓存大小为可用内存的1/8，重写sizeof()方法。

  获取当前key值对应的缓存对象:

mMemoryCache.get(key);

  将对象存放到缓存中

mMemoryCache.put(key, bitmap);