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 = ;
    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() / );

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