这段时间在研究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.<br />
* <b>NOTE:</b> This cache uses only strong references for stored Bitmaps.
*/说明该缓存存储的是强引用的Bitmap对象，同时每当一个bitmap被访问之后，它就会被放到队列的头部，当队列满了需要删除元素时，就会删除队尾的元素，让它变成可以被垃圾回收器回收的对象。
在LruMemoryCache中声明了三个全局变量：
private final LinkedHashMap<String, Bitmap> 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<String, Bitmap>(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<String, Bitmap> 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的缓存类构建自己的缓存！