这段时间在研究Universal-Image-Loader 这个图片处理开源框架，这里主要分析一下它的LRU（Least Resently Used,最近最少使用）内存缓存的实现。 

在UIL它提供的默认缓存类是LruMemoryCache，在它类上面有如下一段注释：

/** * A cache that holds strong references to a limited number of Bitmaps. Each time a Bitmap is accessed, it is moved to * the head of a queue. When a Bitmap is added to a full cache, the Bitmap at the end of that queue is evicted and may become eligible for garbage collection.
 * NOTE: This cache uses only strong references for stored Bitmaps. */

说明该缓存存储的是强引用的Bitmap对象，同时每当一个bitmap被访问之后，它就会被放到队列的头部，当队列满了需要删除元素时，就会删除队尾的元素，让它变成可以被垃圾回收器回收的对象。 

在LruMemoryCache中声明了三个全局变量：

private final LinkedHashMap
    
      map;//存放对象的map容器private final int maxSize; //缓存设定的最大值 /** Size of this cache in bytes */ private int size; //缓存中已经占有的大小
    

它的构造数也同样简单：

public LruMemoryCache(int maxSize) {        if (maxSize <= 0) { throw new IllegalArgumentException("maxSize <= 0"); } this.maxSize = maxSize; this.map = new LinkedHashMap
    
     (0, 0.75f, true); }
    

这里传进来的maxSize参数在默认的情况下是程序进程占用内存总数的八分之一，单位是Byte。 

根据Key值获取对应的bitmap对象，代码超简单：

/**     * Returns the Bitmap for {@code key} if it exists in the cache. If a Bitmap was returned, it is moved to the head     * of the queue. This returns null if a Bitmap is not cached.     */    @Override    public final Bitmap get(String key) { if (key == null) { throw new NullPointerException("key == null"); } synchronized (this) { return map.get(key); } }

存储bitmap对象：

@Override    public final boolean put(String key, Bitmap value) {        if (key == null || value == null) { throw new NullPointerException("key == null || value == null"); } synchronized (this) { size += sizeOf(key, value); //调用sizeOf这个函数获得该bitmap对象的占用内存的大小，并且让缓存总数增加 Bitmap previous = map.put(key, value);//这里就是把对象放入容器中的最核心的一句代码，如果容器中已经有了此元素，则返回该元素的value值，否则返回空 if (previous != null) { size -= sizeOf(key, previous);//如果容器中已经有了此元素，则需要把增加的数量减掉 } } trimToSize(maxSize); //此函数计算是否超出最大限量，是则删除队尾元素 return true; }

这里涉及到两个函数： 

获取图片大小的函数

private int sizeOf(String key, Bitmap value) {        return value.getRowBytes() * value.getHeight(); }

保证缓存内存量不超过设定的最大值

private void trimToSize(int maxSize) {        while (true) { String key; Bitmap value; synchronized (this) { if (size < 0 || (map.isEmpty() && size != 0)) { throw new IllegalStateException(getClass().getName() + ".sizeOf() is reporting inconsistent results!"); } if (size <= maxSize || map.isEmpty()) { break; } Map.Entry
    
      toEvict = map.entrySet().iterator().next(); if (toEvict == null) { break; } key = toEvict.getKey(); value = toEvict.getValue(); map.remove(key); size -= sizeOf(key, value); } } }
    

此外，该类还有一个移除特定key的元素的方法：

/** Removes the entry for {@code key} if it exists. */    @Override    public final Bitmap remove(String key) { if (key == null) { throw new NullPointerException("key == null"); } synchronized (this) { Bitmap previous = map.remove(key); if (previous != null) { size -= sizeOf(key, previous); } return previous; } }

至此整个缓存类就已经解析完了，你会发现其实代码超简单的，其中一个最重要的东西就是存放键值对的容器–LinkedHashMap。LinkedHashMap实现了Map接口，并且具有链表的特性，即有可预知的迭代顺序。通常在默认的情况下，该集合的迭代顺序是按照插入元素的顺序，先插入的元素在队尾，最后插入的在头部；然而当我们调用LinkedHashMap的构造函数LinkedHashMap(int initialCapacity, float loadFactor, boolean accessOrder) ，并传入accessOrder的值为true时，LinkedHashMap就会按照访问先后的顺序迭代，最近被访问的放在队头，最迟访问的在队尾。正是因为这个特性，LinkedHashMap很适合被用来作为LRU缓存的容器。因此有了LinkedHashMap这个神器，我们完全可以仿照UIL的缓存类构建自己的缓存！