android缓存之Lrucache 和LinkedHashMap

两者的区别

网上有很多人使用软引用加载图片的多 ，但是现在已经不再推荐使用这种方式了，
（1）因为从 Android 2.3 (API Level 9)开始，垃圾回收器会更倾向于回收持有软引用或弱引用的对象，
这让软引用和弱引用变得不再可靠。
（2）另外，Android 3.0 (API Level 11)中，图片的数据会存储在本地的内存当中，
因而无法用一种可预见的方式将其释放，这就有潜在的风险造成应用程序的内存溢出并崩溃，
所以我这里用得是LruCache来缓存图片，当存储Image的大小大于LruCache设定的值，系统自动释放内存，
这个类是3.1版本中提供的，如果你是在更早的Android版本中开发，则需要导入android-support-v4的jar包。

先学习下LinkedHashMap

public LinkedHashMap (int initialCapacity, float loadFactor, boolean accessOrder)；

initialCapacity 初始容量

loadFactor 加载因子，一般是 0.75f

accessOrder false 基于插入顺序 true 基于访问顺序（get一个元素后，这个元素被加到最后，使用了LRU 最近最少被使用的调度算法）

boolean accessOrder = true;
Map<String, String> m = new LinkedHashMap<String, String>(20, .80f,accessOrder);
m.put("1", "test1");
m.put("2", "test2");
m.put("3", "test3");
System.out.println(m);　　//{1=test1, 2=test2, 3=test3}

Map<String, String> m = new LinkedHashMap<String, String>(20, .80f,accessOrder);
m.put("1", "test1");
m.put("2", "test2");
m.put("3", "test3");
m.get("1");
m.get("2");
System.out.println(m);    //{3=test3, 1=test1, 2=test2}

boolean accessOrder = false;
Map<String, String> m = new LinkedHashMap<String, String>(20, .80f,accessOrder);
m.put("1", "test1");
m.put("2", "test2");
m.put("3", "test3");
System.out.println(m);　　 //{1=test1, 2=test2, 3=test3}

boolean accessOrder = false;
Map<String, String> m = new LinkedHashMap<String, String>(20, .80f,accessOrder);
m.put("1", "test1");
m.put("2", "test2");
m.put("3", "test3");
m.get("1");
m.get("2");
System.out.println(m);    //{1=test1, 2=test2, 3=test3}

public class MemoryCache {

private final static int MAP_CACHE_SIZE = 15;
private LruCache<String, Bitmap> lruCache = null;
private LinkedHashMap<String, SoftReference<Bitmap>> merCache = null;
private static MemoryCache mc = null;

private MemoryCache() {

merCache = new LinkedHashMap<String, SoftReference<Bitmap>>(
MAP_CACHE_SIZE, 0.75f, true) {
private static final long serialVersionUID = 1L;

@Override
protected boolean removeEldestEntry(
Entry<String, SoftReference<Bitmap>> eldest) {

if (eldest != null) {
return true;
}
return false;
}

};

int lruCacheSize = (int) (Runtime.getRuntime().maxMemory() / 4);

lruCache = new LruCache<String, Bitmap>(lruCacheSize) {

@Override
protected void entryRemoved(boolean evicted, String key,
Bitmap oldValue, Bitmap newValue) {
if (oldValue != null) {
merCache.put(key, new SoftReference<Bitmap>(oldValue));
}
}

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

};
}

//单例模式
public static MemoryCache getInstance() {
if (mc == null) {
mc = new MemoryCache();
}
return mc;
}

//放入一个bitmap
public synchronized void putBitmap(String url, Bitmap bitmap) {
if (bitmap != null) {
lruCache.put(url, bitmap);
}
}

//获取bitmap
public synchronized Bitmap getBitmap(String url) {
if (TextUtils.isEmpty(url)) {
return null;
}
Bitmap bitmap = lruCache.get(url);
if (bitmap != null) {
lruCache.remove(url);
lruCache.put(url, bitmap);
return bitmap;
}
SoftReference<Bitmap> sr = merCache.get(url);
if (sr != null) {
bitmap = sr.get();
if (bitmap != null) {
merCache.remove(url);
lruCache.put(url, bitmap);
return bitmap;
} else {
sr = null;
merCache.remove(url);
}
}
return bitmap;
}

//清空HashMap
public void clear() {
merCache.clear();
}

//删除一个bitmap
public void delete(String url) {
lruCache.remove(url);
merCache.remove(url);
}
}