图片缓存

public class ImageLoader {

    ExecutorService mExecutorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
    //内存缓存
    ImageCache mImageCache = new MemoryCache();
    public void setmImageCache(ImageCache imageCache){
        mImageCache = imageCache;
    }
    public void dispalyImage(final String url ,final ImageView imageView){
        Bitmap bitmap = mImageCache.get(url);
        if(bitmap != null){
            imageView.setImageBitmap(bitmap);
            return;
        }
        imageView.setTag(url);
        mExecutorService.submit(new Runnable() {
            @Override
            public void run() {
                Bitmap bitmap = downloadImage(url);
                if(bitmap == null){
                    return;
                }
                if (imageView.getTag().equals(url)){
                    imageView.setImageBitmap(bitmap);
                }
                mImageCache.put(url,bitmap);
            }
        });
    }
    public Bitmap downloadImage(String imageUrl){
        Bitmap bitmap = null;
        try{
            URL url = new URL(imageUrl);
            final HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            bitmap = BitmapFactory.decodeStream(conn.getInputStream());
            conn.disconnect();
        }catch (Exception e){
            e.printStackTrace();
        }
        return bitmap;
    }
}

public interface ImageCache {
    public void put(String url, Bitmap bitmap);
    public Bitmap get(String url);

public class MemoryCache implements ImageCache {
    LruCache<String,Bitmap> mImageCache;

    public MemoryCache() {
        initImageCache();
    }

    private void initImageCache(){
        final  int maxMemory = (int )(Runtime.getRuntime().maxMemory()/1024);
        final int cacheSize = maxMemory / 4;
        mImageCache = new LruCache<String,Bitmap>(cacheSize){
            @Override
            protected int sizeOf(String key, Bitmap value) {
                return value.getRowBytes()*value.getHeight()/1024;
            }
        };
    }
    @Override
    public void put(String url,Bitmap bitmap){
        mImageCache.put(url,bitmap);
    }
    @Override
    public Bitmap get(String url){
        return mImageCache.get(url);
    }
}

public class DiskCache implements ImageCache{
    static String cacheDir = "sdcard/cache/";
    @Override
    public Bitmap get(String url){
        return BitmapFactory.decodeFile(cacheDir+url);
    }
    @Override
    public void put(String url ,Bitmap bitmap){
        FileOutputStream fileOutputStream = null;
        try{
            fileOutputStream = new FileOutputStream(cacheDir+url);
            bitmap.compress(Bitmap.CompressFormat.PNG,100,fileOutputStream);
        }catch(FileNotFoundException e){
            e.printStackTrace();
        }finally {
            if (fileOutputStream != null){
                try{
                    fileOutputStream.close();
                }catch (IOException e){
                    e.printStackTrace();
                }
            }
        }
    }
}

public class DoubleCache implements ImageCache{
    static  final String sdcardDir = "/sdcard/cache/";
    MemoryCache mMemoryCache = new MemoryCache();
    DiskCache mDiskCache = new DiskCache();
    @Override
    public Bitmap get(String url){
        Bitmap bitmap = mMemoryCache.get(url);
        if(bitmap == null){
            bitmap = mDiskCache.get(url);
        }
        return bitmap;
    }
    @Override
    public void put(String url,Bitmap bitmap){
        mMemoryCache.put(url,bitmap);
        mDiskCache.put(sdcardDir+url,bitmap);
    }
}