文章主要介绍了：
1.LruCache的基本使用
2.LruCache的源码分析
3.基于LinkedHashMap的实现
一、LruCache缓存的实例代码。
假设存的是图片·
long maxMemory = (int) Runtime.getRuntime().maxMemory();
int memorySize = (int) (maxMemory/8);
LruCache<String ,Bitmap> lruCache = new LruCache<String ,Bitmap>(memorySize){
@Override
protected int sizeOf(String key, Bitmap value) {
return value.getByteCount();
}
};
maxMemory是缓存定义的最大的值，不能超过这个值，负责就会被回收。
重写sizeOf是为了计算每个数值的大小，等累计缓存的数值超出定义的最大值就会回收。
- 操作方式：
// 把Value对象加入到缓存中
public void putValueToMemory(String key, Bitmap bitmap) {
if (getValueFromMemory(key) == null) {
lruCache.put(key, bitmap);
}
}
// 从缓存中得到value对象
public Bitmap getValueFromMemory(String key) {
return lruCache.get(key);
}
// 从缓存中删除指定的value
public void removeValueMemory(String key) {
lruCache.remove(key);
}
二 、源码调用
（1）属性
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;
LinkedHashMap为核心类，Lru也是基于LinkedHashMap从而实现的。
（2）LruCache只有一个构造方法，初始了LinkedHashMap
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);
}
LinkedHashMap自身是默认 按照插入的顺序进行排序的，此处初始化的时候new LinkedHashMap<K, V>(0, 0.75f, true); 传入true则将LinkedHashMap的顺序改为访问顺序，说明Lru初始化的时候默认的是访问顺序。
（3）LruCache的put方法：
public final V put(K key, V value) {
if (key == null || value == null) {
throw new NullPointerException("key == null || value == null");
}
V previous;
synchronized (this) {对map进行操作之前，先进行同步操作
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);判断是否需要移除LinkedHashMap中的元素
return previous;
}
safeSizeOf方法,是计算LruCache的已经缓存的大小.
entryRemoved(false, key, previous, value);如果找的到对应的key的话是替换新值，不存在的话就是新增。true为删除条目生成空间，false反之.
trimToSize判断是否需要移除LinkedHashMap中的元素
public void trimToSize(int maxSize) {
while (true) { **循环直到返回<=缓存的最大大小
K key;
V value;
synchronized (this) {**同步
if (size < 0 || (map.isEmpty() && size != 0)) {
throw new IllegalStateException(getClass().getName()
+ ".sizeOf() is reporting inconsistent results!");
}
** 如果当前的size小于等于最大的size则直接返回，不需要删除数据
if (size <= maxSize) {
break;
}
**如果size超出了最大的size，则需要进行删除数据，
**map.eldest获取表头的数据，进行删除
Map.Entry<K, V> toEvict = map.eldest();
if (toEvict == null) {
break;
}
key = toEvict.getKey();
value = toEvict.getValue();
map.remove(key);**删除数据
size -= safeSizeOf(key, value);**重新计算缓存大小
evictionCount++;
}
entryRemoved(true, key, value, null);
}
}
如同上述注释中写的一样，可以看出，就是不断的循环移除LinkedHashMap双向链表表头的元素，直到缓存的大小小于等于缓存大小为止。
- map.eldest()返回值
public Map.Entry<K, V> eldest() {
return head;
}
LinkedHashMap map.eldest()的调用是返回表头的集合数据head。
LinkedHashMap继承HashMap，重写的方法中并没有重写put，所以put使用的还是HashMap的put方法，在LruCache类中呢，put相当于调用的是HashMap的put，get调用的是LinkedHashMap重写的get，此处主要就看一下这个put和get方法。在HashMap put方法中，最终会回调afterNodeAccess给LinkedHashMap，在LinkedHashMap的get方法中，最终也是走的这个方法，来操作head集合的赋值，最近的操作的数据则移到表尾。
- LinkedHashMap中head的处理
void afterNodeAccess(Node<K,V> e) { move node to last
LinkedHashMapEntry<K,V> last;
if (accessOrder && (last = tail) != e) {
LinkedHashMapEntry<K,V> p =
(LinkedHashMapEntry<K,V>)e, b = p.before, a = p.after;
p.after = null;
if (b == null)
head = a;
else
b.after = a;
if (a != null)
a.before = b;
else
last = b;
if (last == null)
head = p;
else {
p.before = last;
last.after = p;
}
tail = p;
++modCount;
}
}
对LinkedHashMap的put和get操作，都会让被操作的Entry移动到双向链表的表尾，删除数据则是从表头开始的，就符合Lru算法的要求。
（4）LruCache的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++;
}
V createdValue = create(key);
if (createdValue == null) { 通过Key尝试创建一个新值，默认返回为null。可重写
return null;
}
synchronized (this) {
createCount++;
如果我们重写了create(key)方法而且返回值不为空，那么将上述的key与这个返回值写入到map当中
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;
}
}
V createdValue = create(key);可重写create，此处是判断当前是值是不是空的，如果不是空的，会将创建的key与createdValue 值捆绑，存到map中。
（5）LruCache的remove方法是从缓存中去删除：
public final V remove(K key) {
if (key == null) {
throw new NullPointerException("key == null");
}
V previous;
synchronized (this) {
previous = map.remove(key);
if (previous != null) {
size -= safeSizeOf(key, previous);
}
}
if (previous != null) {
entryRemoved(false, key, previous, null);
}
return previous;
}
根据Key删除所对应的value值。
总结：
Lru是基于LinkedHashMap实现的， 默认为访问顺序。
HashMap无序，而LinkedHashMap是有序的。序列可分为插入顺序和访问顺序，若是访问顺序，操作已存在的数据时会将其移植双链表表尾。
