為什麼需要圖片快取

android預設給每個應用只分配16M的記憶體，所以如果載入過多的圖片，為了防止記憶體溢位，應該將圖片快取起來。圖片的三級快取分別是：

1. 記憶體快取
2. 本地快取
3. 網路快取

其中，記憶體快取應優先載入，它速度最快；本地快取次優先載入，它速度也快；網路快取不應該優先載入，它走網路，速度慢且耗流量。

三級快取的具體實現

網路快取

• 根據圖片的url去載入圖片
• 在本地和記憶體中快取

    public class NetCacheUtils {

        private LocalCacheUtils mLocalCacheUtils;
        private
 
 MemoryCacheUtils mMemoryCacheUtils;

        public NetCacheUtils(LocalCacheUtils localCacheUtils,
                MemoryCacheUtils memoryCacheUtils) {
            mLocalCacheUtils = localCacheUtils;
            mMemoryCacheUtils = memoryCacheUtils;
        }

        /**
         * 從網路下載圖片
         * 
         * @param
 
 ivPic
         * @param url
         */
        public void getBitmapFromNet(ImageView ivPic, String url) {
            new BitmapTask().execute(ivPic, url);// 啟動AsyncTask,
                                                    // 引數會在doInbackground中獲取
        }

        /**
         * Handler和執行緒池的封裝
         * 
         * 第一個泛型: 引數型別 第二個泛型: 更新進度的泛型, 第三個泛型是onPostExecute的返回結果
         * 
         * 
         */
 

        class BitmapTask extends AsyncTask<Object, Void, Bitmap> {

            private ImageView ivPic;
            private String url;

            /**
             * 後臺耗時方法在此執行, 子執行緒
             */
            @Override
            protected Bitmap doInBackground(Object... params) {
                ivPic = (ImageView) params[0];
                url = (String) params[1];

                ivPic.setTag(url);// 將url和imageview繫結

                return downloadBitmap(url);
            }

            /**
             * 更新進度, 主執行緒
             */
            @Override
            protected void onProgressUpdate(Void... values) {
                super.onProgressUpdate(values);
            }

            /**
             * 耗時方法結束後,執行該方法, 主執行緒
             */
            @Override
            protected void onPostExecute(Bitmap result) {
                if (result != null) {
                    String bindUrl = (String) ivPic.getTag();

                    if (url.equals(bindUrl)) {// 確保圖片設定給了正確的imageview
                        ivPic.setImageBitmap(result);
                        mLocalCacheUtils.setBitmapToLocal(url, result);// 將圖片儲存在本地
                        mMemoryCacheUtils.setBitmapToMemory(url, result);// 將圖片儲存在記憶體
                        System.out.println("從網路快取讀取圖片啦...");
                    }
                }
            }
        }

        /**
         * 下載圖片
         * 
         * @param url
         * @return
         */
        private Bitmap downloadBitmap(String url) {

            HttpURLConnection conn = null;
            try {
                conn = (HttpURLConnection) new URL(url).openConnection();

                conn.setConnectTimeout(5000);
                conn.setReadTimeout(5000);
                conn.setRequestMethod("GET");
                conn.connect();

                int responseCode = conn.getResponseCode();
                if (responseCode == 200) {
                    InputStream inputStream = conn.getInputStream();

                    //圖片壓縮處理
                    BitmapFactory.Options option = new BitmapFactory.Options();
                    option.inSampleSize = 2;//寬高都壓縮為原來的二分之一, 此引數需要根據圖片要展示的大小來確定
                    option.inPreferredConfig = Bitmap.Config.RGB_565;//設定圖片格式

                    Bitmap bitmap = BitmapFactory.decodeStream(inputStream, null, option);
                    return bitmap;
                }

            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                conn.disconnect();
            }

            return null;
        }
    }

本地快取

• 兩個方法：設定本地快取，獲取本地快取

    public class LocalCacheUtils {

        public static final String CACHE_PATH = Environment
                .getExternalStorageDirectory().getAbsolutePath() + "/local_cache";

        /**
         * 從本地sdcard讀圖片
         */
        public Bitmap getBitmapFromLocal(String url) {
            try {
                String fileName = MD5Encoder.encode(url);
                File file = new File(CACHE_PATH, fileName);

                if (file.exists()) {
                    Bitmap bitmap = BitmapFactory.decodeStream(new FileInputStream(
                            file));
                    return bitmap;
                }

            } catch (Exception e) {
                e.printStackTrace();
            }

            return null;
        }

        /**
         * 向sdcard寫圖片
         * 
         * @param url
         * @param bitmap
         */
        public void setBitmapToLocal(String url, Bitmap bitmap) {
            try {
                String fileName = MD5Encoder.encode(url);

                File file = new File(CACHE_PATH, fileName);

                File parentFile = file.getParentFile();
                if (!parentFile.exists()) {// 如果資料夾不存在, 建立資料夾
                    parentFile.mkdirs();
                }

                // 將圖片儲存在本地
                bitmap.compress(CompressFormat.JPEG, 100,
                        new FileOutputStream(file));
            } catch (Exception e) {
                e.printStackTrace();
            }

        }
    }

記憶體快取

• 兩個方法：設定記憶體快取，獲取記憶體快取
• 問題：
  
  1. 如果使用HashMap儲存圖片時，當圖片越來越多時，會導致記憶體溢位，因為它是強引用，java的垃圾回收器不會回收。
  2. 如若改成軟引用SoftReference（記憶體不夠時,垃圾回收器會考慮回收），仍有一個問題：在android2.3+, 系統會優先將SoftReference的物件提前回收掉, 即使記憶體夠用。
• 解決辦法：可以用LruCache來解決上述記憶體不回收或提前回收的問題。least recentlly use 最少最近使用演算法 它會將記憶體控制在一定的大小內, 超出最大值時會自動回收, 這個最大值開發者自己定

        public class MemoryCacheUtils {

            // private HashMap<String, SoftReference<Bitmap>> mMemoryCache = new
            // HashMap<String, SoftReference<Bitmap>>();
            private LruCache<String, Bitmap> mMemoryCache;

            public MemoryCacheUtils() {
                long maxMemory = Runtime.getRuntime().maxMemory() / 8;// 模擬器預設是16M
                mMemoryCache = new LruCache<String, Bitmap>((int) maxMemory) {
                    @Override
                    protected int sizeOf(String key, Bitmap value) {
                        int byteCount = value.getRowBytes() * value.getHeight();// 獲取圖片佔用記憶體大小
                        return byteCount;
                    }
                };
            }

            /**
             * 從記憶體讀
             * 
             * @param url
             */
            public Bitmap getBitmapFromMemory(String url) {
                // SoftReference<Bitmap> softReference = mMemoryCache.get(url);
                // if (softReference != null) {
                // Bitmap bitmap = softReference.get();
                // return bitmap;
                // }
                return mMemoryCache.get(url);
            }

            /**
             * 寫記憶體
             * 
             * @param url
             * @param bitmap
             */
            public void setBitmapToMemory(String url, Bitmap bitmap) {
                // SoftReference<Bitmap> softReference = new
                // SoftReference<Bitmap>(bitmap);
                // mMemoryCache.put(url, softReference);
                mMemoryCache.put(url, bitmap);
            }
        }

圖片壓縮

    //圖片壓縮處理（在從網路獲取圖片的時候就進行壓縮）
    BitmapFactory.Options option = new BitmapFactory.Options();
    option.inSampleSize = 2;//寬高都壓縮為原來的二分之一, 此引數需要根據圖片要展示的大小來確定
    option.inPreferredConfig = Bitmap.Config.RGB_565;//設定圖片格式
    Bitmap bitmap = BitmapFactory.decodeStream(inputStream, null, option);