扣丁学堂——Bitmaps与优化（处理较大图片，缓存图片）

一丶源码见本文

二丶演示（略）

三丶课程讲解

/**
 * 磁盘缓存 工具类
 */
public class DiskLruCacheUtils {
    private static DiskLruCacheUtils diskLruCacheUtils;

    //磁盘缓存插件
    private DiskLruCache diskLruCache;
    private Context context;

    private DiskLruCacheUtils() {
    }

    ;

    /**
     * 单例 提供实例
     *
     * @return
     */
    public static DiskLruCacheUtils getInstance() {
        if (diskLruCacheUtils == null) {
            diskLruCacheUtils = new DiskLruCacheUtils();
        }
        return diskLruCacheUtils;
    }

    /**
     * 磁盘缓存
     *
     * @param context
     * @param disk_cache_subdir ：缓存目录
     * @param disk_cache_size   ：缓存大小
     */
    public void open(Context context, String disk_cache_subdir, int disk_cache_size) {
        try {
            this.cOntext= context;
            /***
             *  open()方法 接收四个参数，
             *  第一个参数指定的是数据的缓存地址
             *  第二个参数拽定当前应用程序的版本号
             *  第三个参数 指定一个key 可以对应多个缓存文件，基本都是传1
             *  第四个参数指定最多可以缓存多少字节的数据，通常10MB
             */

            diskLruCache = diskLruCache.open(getCacheDir(disk_cache_subdir), getAppVersion(), 1, disk_cache_size);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    /**
     * 根据key 获取 磁盘缓存
     *
     * @param url
     * @return
     */
    public InputStream get(String url) {
        String key = hashkeyForDisk(url);
        try {
            DiskLruCache.Snapshot snapshot = diskLruCache.get(key);
            if (snapshot != null) {
                return snapshot.getInputStream(0);//拿 第几个图片，因为存的时侯是 1
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }


    /**
     * 磁盘 缓存 存入方法
     *
     * @param url
     */
    public void put(final String url) {
        new AsyncTask() {
            @Override
            protected Void doInBackground(String... params) {

                //计算 md5 的摘要转化为十六进制的字符串，做为存入的键 ，相同的字符串，计算出来是一样
                String key = hashkeyForDisk(params[0]);

                DiskLruCache.Editor editor = null;
                try {
                    URL uri = new URL(params[0]);
                    HttpURLConnection cOnn= (HttpURLConnection) uri.openConnection();

                    //key作用：存入图片的key值
                    editor = diskLruCache.edit(key);

                    //输入输出缓存流
                    BufferedOutputStream out = new BufferedOutputStream(editor.newOutputStream(0), 8 * 1024);
                    BufferedInputStream in = new BufferedInputStream(conn.getInputStream(), 8 * 1024);

                    byte[] bytes = new byte[1024];
                    int len = -1;

                    //写入磁盘缓存
                    while ((len = in.read(bytes)) != -1) {
                        out.write(bytes, 0, len);
                    }
                    out.close();
                    in.close();
                    editor.commit();
                    conn.disconnect();

                } catch (MalformedURLException e) {
                    e.printStackTrace();
                } catch (IOException e) {

                    try {
                        editor.abort();//放弃写入
                    } catch (IOException e1) {
                        e1.printStackTrace();
                    }
                    e.printStackTrace();
                }

                return null;
            }
        };
    }

    /**
     * 计算字符 MD5 摘要
     *
     * @param key
     * @return
     */
    private String hashkeyForDisk(String key) {

        String cacheKey;
        try {
            final MessageDigest messageDigest = MessageDigest.getInstance("MD5");

            messageDigest.update(key.getBytes());

            //将字符串摘要 计算为 十六进制的 字符串 作为 key
            cacheKey = bytestoHexString(messageDigest.digest());

        } catch (NoSuchAlgorithmException e) {
            cacheKey = String.valueOf(key.hashCode());
            e.printStackTrace();
        }

        return cacheKey;
    }

    /**
     * 计算为 十六进制的 字符串
     *
     * @param digest
     * @return
     */
    private String bytestoHexString(byte[] digest) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i             String hex = Integer.toHexString(0xFF & digest[i]);
            if (hex.length() == 1) {
                sb.append('0');
            } else {
                sb.append(hex);
            }
        }
        return sb.toString();
    }


    /**
     * 获取缓存 目录
     *
     * @param name :缓存文件
     * @return sdcard 上的 私有目录
     * context.getExternalCacheDir().getPath() ：在 mnt/sdcard/android/data/应用程序包/cache文件夹路径
     * 

     * 安装应用程序下的 私有目录
     * context.getCacheDir().getPath() ：在 data/data/应用程序包/cache
     */
    private File getCacheDir(String name) {

        String cachePath = Environment.getExternalStorageState() == Environment.MEDIA_MOUNTED
                || !Environment.isExternalStorageRemovable() ?
                context.getExternalCacheDir().getPath() : context.getCacheDir().getPath();

        return new File(cachePath + File.separator + name);


    }


    /**
     * 获取当前应用程序的版本
     */
    public int getAppVersion() {

        try {
            return context.getPackageManager().getPackageInfo(context.getPackageName(), 0).versionCode;
        } catch (PackageManager.NameNotFoundException e) {
            e.printStackTrace();
        }

        return 1;
    }

}

//本地内存缓存实例
public class MainActivity extends AppCompatActivity {


    private ImageView imageView;

    private LruCache lruCache;

    private DiskLruCacheUtils diskLruCacheUtils;

    //磁盘缓存文件名
    private static final String DISK_CACHE_SUBDIR = "temp";

    //磁盘缓存空间大小
    private static final int DISK_CACHE_SIZE = 1024 * 1024 * 10;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        imageView = (ImageView) findViewById(R.id.imageView);

        //获取当前activity的内存大小
        ActivityManager am = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
        int memoryClass = am.getMemoryClass();

        //计算缓存的大小 字节 8/1 的内存作为缓存大小
        final int cacheSize = memoryClass / 8 * 1024 * 1024;

        lruCache = new LruCache<>(cacheSize);


        diskLruCacheUtils = DiskLruCacheUtils.getInstance();

        diskLruCacheUtils.open(this, DISK_CACHE_SUBDIR, DISK_CACHE_SIZE);


    }


    /**
     * 显示图片
     *
     * @param view
     */
    public void show(View view) {
        String key = String.valueOf(R.mipmap.as);

        Bitmap bitmap = getBitmapCache(key);

        //不缓存中没有时，则再去找
        if (bitmap == null) {
            //获取 采样 缩放的位图
            bitmap = decodeSampleBitmapFromResource(getResources(), R.mipmap.as, 100, 100);

            //图片存入缓存中
            addBitmapCache(key, bitmap);
        } else {
            System.out.print("lruCache:缓存了");
        }

        imageView.setImageBitmap(bitmap);

    }


    //添加到缓存
    public void addBitmapCache(String key, Bitmap bitmap) {
        if (getBitmapCache(key) == null) {
            lruCache.put(key, bitmap);
        }
    }


    //从缓存中 读取对象
    public Bitmap getBitmapCache(String key) {
        return lruCache.get(key);
    }


    /**
     * 位图重样 采样
     *
     * @param res             ：资源对象
     * @param resid           ：资源的id
     * @param reqWidth        :要显示的宽
     * @param reqHeight：要显示的高
     * @return
     */
    public Bitmap decodeSampleBitmapFromResource(Resources res, int resid, int reqWidth, int reqHeight) {

        BitmapFactory.Options optiOns= new BitmapFactory.Options();

        //只解析边界，不占用内存
        options.inJustDecodeBounds = true;

        //得到边界的 宽 和 高 ，并存入 options中
        BitmapFactory.decodeResource(res, resid, options);

        //得到缩放 值
        options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);

        options.inJustDecodeBounds = false;// false ：图片加载到内存中去

        //再解码，这时图片就加载到内存中了，这时的图片是 缩放比例后的图片
        return BitmapFactory.decodeResource(res, resid, options);
    }

    /**
     * 计算位图的 采样比例
     *
     * @param options
     * @param reqWidth  ：必须的宽
     * @param reqHeight
     * @return
     */
    public int calculateInSampleSize(BitmapFactory.Options options, int reqWidth, int reqHeight) {

        //获取位图的原大小
        int w = options.outWidth;
        int h = options.outHeight;

        int inSampleSize = 1;

        if (w > reqWidth || h > reqHeight) {
            if (w > h) {
                inSampleSize = Math.round((float) h / (float) reqHeight);
            } else {
                inSampleSize = Math.round((float) w / (float) reqWidth);
            }
        }

        return inSampleSize;
    }
}