你的位置:首页 > 操作系统

[操作系统]android 网络加载图片,对图片资源进行优化,并且实现内存双缓存 + 磁盘缓存


经常会用到 网络文件 比如查看大图片数据 资源优化的问题,当然用开源的项目  Android-Universal-Image-Loader  或者 ignition 都是个很好的选择。

在这里把原来 写过的优化的代码直接拿出来,经过测试千张图片效果还是不错的。

免费培训课:http://www.jinhusns.com/Products/Curriculum/?type=xcj

 

工程目录

 

至于 Activity 就是加载了 1个网格布局

01./**
02.*   实现 异步加载 和   2级缓存
03.*/
04.public class ImagedownActivity extends Activity {
05. 
06.public static String filepath;
07.@Override
08.public void onCreate(Bundle savedInstanceState) {
09.super.onCreate(savedInstanceState);
10.setContentView(R.layout.main);
11.filepath =   this.getCacheDir().getAbsolutePath();
12.GridView gv=(GridView)findViewById(R.id.gridview01);
13.//设置列数
14.gv.setNumColumns(3);
15.//配置适配器
16.gv.setAdapter(new Myadapter(this));
17.}
18. 
19.@Override
20.protected void onDestroy() {
21.// TODO Auto-generated method stub
22.//activity 销毁时,清除缓存
23.MyImageLoader.removeCache(filepath);
24.super.onDestroy();
25.}
26. 
27.}


 接下来 Myadapter.java(给网格每个item塞入图片 )在生成每个 item 异步请求网络获取image

01.public class Myadapter extends BaseAdapter {
02.private Context context;
03.private String  root ="http://192.168.0.100:8080/Android_list/";
04.private String[] URLS;
05.private final MyImageLoader  myImageLoader = new MyImageLoader(context);;
06. 
07./**
08.* adapter 初始化的时候早一堆数据
09.* 这里我请求的是自己搭的服务器
10.* @param context
11.*/
12.public  Myadapter(Context context){
13.this.context =context;
14.URLS = new String[999];
15.for (int i = 0; i < 999; i++) {
16.URLS[i] = root + (i+1)+".jpg";
17.}  
18.}
19. 
20. 
21.@Override
22.public int getCount() {
23.return URLS.length;
24.}
25. 
26.@Override
27.public Object getItem(int position) {
28.return URLS[position];
29.}
30. 
31.@Override
32.public long getItemId(int position) {
33.return URLS[position].hashCode();
34.}
35. 
36. 
37. 
38.@Override
39.public View getView(int position, View view, ViewGroup parent) {
40.ImageView imageView;
41.if(view==null){
42.imageView=new ImageView(context);
43.imageView.setLayoutParams(new GridView.LayoutParams(200,190));
44.imageView.setAdjustViewBounds(false);
45.imageView.setScaleType(ImageView.ScaleType.CENTER_CROP);
46.imageView.setPadding(5, 5, 5, 5);
47.}else{
48.imageView=(ImageView)view;
49.}
50.myImageLoader.downLoad(URLS[position], (ImageView)imageView , context);
51.return imageView;
52.}
53.}


 MyImageLoader.java

001.public class MyImageLoader { 
002. 
003.//最大内存 
004.final static int memClass = (int) Runtime.getRuntime().maxMemory();   
005.private Context context; 
006. 
007.// 是否缓存到硬盘 
008.private boolean  diskcache = true
009. 
010.// 定义一级 缓存的图片数 
011.private static final int catch_num = 10
012. 
013.// 定义二级缓存 容器  软引用 
014.private static ConcurrentHashMap<String, SoftReference<Bitmap>> current_hashmap = new ConcurrentHashMap<String, SoftReference<Bitmap>>(); 
015. 
016.// 定义一级缓存容器  强引用       (catch_num ,0.75f,true) 默认参 数                                                                                                                        2.加载因子默认        3.排序模式 true 
017.private static LinkedHashMap<String, Bitmap> link_hashmap = new LinkedHashMap<String, Bitmap>(catch_num ,0.75f,true) { 
018. 
019.// 必须实现的方法 
020.protected boolean removeEldestEntry(java.util.Map.Entry<String, Bitmap> eldest) { 
021./** 当一级缓存中 图片数量大于 定义的数量 放入二级缓存中
022.*/ 
023.if (this.size() > catch_num) { 
024.// 软连接的方法 存进二级缓存中 
025.current_hashmap.put(eldest.getKey(), new SoftReference<Bitmap>( 
026.eldest.getValue())); 
027.//缓存到本地 
028.cancheToDisk(eldest.getKey(),eldest.getValue() ); 
029. 
030.return true
031.
032.return false
033.}; 
034.}; 
035. 
036.public MyImageLoader(Context context) { 
037. 
038.
039. 
040. 
041./**   
042.*  外部调用此方法   进行下载图片  
043.*/ 
044.public void downLoad(String key , ImageView imageView,Context context){ 
045.// 先从缓存中找   。   
046.context = this.context; 
047. 
048.Bitmap bitmap = getBitmapFromCache(key); 
049.if( null!= bitmap){  
050.imageView.setImageBitmap(bitmap); 
051.cancleDownload(key, imageView);         //取消下载 
052.return
053.}     
054. 
055.// 缓存中 没有  把当前的 imageView 给他 得到 task  
056.if(cancleDownload(key, imageView)){     //没有任务进行。,。。开始下载 
057.ImageDownloadTask task = new ImageDownloadTask(imageView); 
058.Zhanwei_Image  zhanwei_image = new Zhanwei_Image(task); 
059.//先把占位的图片放进去 
060.imageView.setImageDrawable(zhanwei_image); 
061.// task执行任务 
062.task.execute(key);  
063.
064.
065. 
066. 
067./** 此方法 用于优化  : 用户直接 翻到 哪个 就先加载 哪个、
068.* @param key                - URL
069.* @param imageView          - imageView
070.*  core: 给当前的 imageView 得到给他下载的 task
071.*/ 
072. 
073.private boolean cancleDownload(String key,ImageView imageView){ 
074.// 给当前的 imageView 得到给他下载的 task 
075.ImageDownloadTask task = getImageDownloadTask(imageView); 
076.if(null != task){ 
077.String down_key = task.key; 
078.if( null == down_key || !down_key.equals(key)){ 
079.task.cancel(true);        // imageview 和 url 的key不一样       取消下载    
080.}else
081.return false;      //正在下载:  
082.}   
083.
084.return true;            //没有正在下载 
085.
086. 
087. 
088. 
089.//  public void getThisProcessMemeryInfo() { 
090.//        int pid = android.os.Process.myPid(); 
091.//        android.os.Debug.MemoryInfo[] memoryInfoArray = activityManager.getProcessMemoryInfo(new int[] {pid}); 
092.//        System.out.println("本应用当前使用了" + (float)memoryInfoArray[0].getTotalPrivateDirty() / 1024 + "mb的内存"); 
093.//    } 
094. 
095. 
096. 
097./**
098.* 从缓存中得到 图片的方法 1.先从一级 缓存找 linkhashmap 不是线程安全的 必须要加同步
099.*/ 
100.public Bitmap getBitmapFromCache(String key) { 
101.//1.先在一级缓存中找 
102.synchronized (link_hashmap) { 
103.Bitmap bitmap = link_hashmap.get(key); 
104.if (null != bitmap) { 
105.link_hashmap.remove(key); 
106.// 按照 LRU是Least Recently Used 近期最少使用算法 内存算法 就近 就 原则 放到首位 
107.link_hashmap.put(key, bitmap); 
108.System.out.println(" 在缓存1中找图片了 =" +key); 
109.return bitmap; 
110.
111.
112. 
113.// 2. 到二级 缓存找 
114.SoftReference<Bitmap> soft = current_hashmap.get(key); 
115.if (soft != null) { 
116.//得到 软连接 中的图片 
117.Bitmap soft_bitmap = soft.get();       
118.if (null != soft_bitmap) { 
119.System.out.println(" 在缓存2中找图片了 =" +key); 
120.return soft_bitmap; 
121.
122.} else
123.// 没有图片的话 把这个key删除 
124.current_hashmap.remove(key);       
125.
126. 
127. 
128.//3.都没有的话去从外部缓存文件读取 
129.if(diskcache){ 
130.Bitmap bitmap = getBitmapFromFile(key); 
131.if(bitmap!= null){ 
132.link_hashmap.put(key, bitmap);   //将图片放到一级缓存首位 
133.return bitmap; 
134.
135.
136. 
137.return null
138.
139. 
140. 
141./**
142.* 缓存到本地文件
143.* @param key
144.* @param bitmap
145.*/ 
146.public static void cancheToDisk(String key ,Bitmap bitmap ){ 
147.//2.缓存bitmap至/data/data/packageName/cache/文件夹中 
148.try
149.String fileName = getMD5Str(key); 
150.String filePath = ImagedownActivity.filepath + "/" + fileName; 
151.System.out.println("缓存到本地===" + filePath); 
152.FileOutputStream fos = new FileOutputStream(filePath); 
153.bitmap.compress(Bitmap.CompressFormat.JPEG, 100, fos); 
154. 
155.} catch (Exception e) { 
156. 
157.
158.
159. 
160. 
161./**
162.* 从外部文件缓存中获取bitmap
163.* @param url
164.* @return
165.*/ 
166.private Bitmap getBitmapFromFile(String url){ 
167.Bitmap bitmap = null
168.String fileName = getMD5Str(url); 
169.if(fileName == null){ 
170.return null
171.}    
172.String filePath = ImagedownActivity.filepath + "/" + fileName;       
173.try
174.FileInputStream fis = new FileInputStream(filePath); 
175.bitmap = BitmapFactory.decodeStream(fis); 
176.System.out.println("在本地缓存中找到图片==="+ filePath); 
177.} catch (FileNotFoundException e) { 
178.System.out.println("getBitmapFromFile==="+ e.toString()); 
179.e.printStackTrace(); 
180.bitmap = null
181.
182.return bitmap; 
183.
184. 
185. 
186. 
187./**
188.* 清理文件缓存
189.* @param dirPath
190.* @return
191.*/ 
192.public static boolean removeCache(String dirPath) { 
193.File dir = new File(dirPath); 
194.File[] files = dir.listFiles(); 
195.if(files == null || files.length == 0) { 
196.return true
197.
198.int dirSize = 0
199.//这里删除所有的缓存 
200.int all_ = (int) ( 1 * files.length + 1); 
201.//对files 进行排序 
202.Arrays.sort(files, new FileLastModifiedSort()); 
203.for (int i = 0; i < all_ ; i++) { 
204.files[i].delete(); 
205.
206.return true
207.
208. 
209. 
210./**
211.* 根据文件最后修改时间进行排序
212.*/ 
213.private static class FileLastModifiedSort implements Comparator<File> { 
214.@Override 
215.public int compare(File lhs, File rhs) { 
216.if(lhs.lastModified() > rhs.lastModified()) { 
217.return 1
218.} else if(lhs.lastModified() == rhs.lastModified()) { 
219.return 0
220.} else
221.return -1
222.
223.
224.
225. 
226. 
227./**  
228.* MD5 加密  
229.*/    
230.private static String getMD5Str(String str) {    
231.MessageDigest messageDigest = null;    
232.try {    
233.messageDigest = MessageDigest.getInstance("MD5");    
234.messageDigest.reset();    
235.messageDigest.update(str.getBytes("UTF-8"));    
236.} catch (NoSuchAlgorithmException e) {    
237.System.out.println("NoSuchAlgorithmException caught!");    
238.return null
239.} catch (UnsupportedEncodingException e) {    
240.e.printStackTrace(); 
241.return null
242.}    
243. 
244.byte[] byteArray = messageDigest.digest();    
245.StringBuffer md5StrBuff = new StringBuffer();    
246.for (int i = 0; i < byteArray.length; i++) {                
247.if (Integer.toHexString(0xFF & byteArray[i]).length() == 1)    
248.md5StrBuff.append("0").append(Integer.toHexString(0xFF & byteArray[i]));    
249.else    
250.md5StrBuff.append(Integer.toHexString(0xFF & byteArray[i]));    
251.}    
252.return md5StrBuff.toString();    
253.}   
254. 
255. 
256.// ------------------------ 异步加载---------------------------- 
257./**
258.*  占位的 图片 或者 颜色      用来绑定 相应的图片
259.*/   
260.class Zhanwei_Image extends ColorDrawable{ 
261.//里面存放 相应 的异步 处理时加载好的图片 ----- 相应的 task 
262.private final WeakReference<ImageDownloadTask>  taskReference; 
263.public Zhanwei_Image(ImageDownloadTask task){    
264.super(Color.BLUE); 
265.taskReference = new WeakReference<MyImageLoader.ImageDownloadTask>(task);  
266.}   
267.// 返回去这个 task 用于比较 
268.public ImageDownloadTask getImageDownloadTask(){ 
269.return taskReference.get(); 
270.
271.
272. 
273. 
274.// 根据 给 的 iamgeView、 得到里面的 task  用于和当前的 task比较是不是同1个 
275.private ImageDownloadTask getImageDownloadTask(ImageView imageView){ 
276.if( null != imageView){ 
277.Drawable drawable = imageView.getDrawable();     
278.if( drawable instanceof Zhanwei_Image) 
279.return ((Zhanwei_Image)drawable).getImageDownloadTask(); 
280. 
281.
282.return null
283.
284. 
285. 
286. 
287./**
288.* 把图片 添加到缓存中
289.*/ 
290.public void addBitmap(String key, Bitmap bitmap) { 
291.if (null != bitmap) { 
292.synchronized (link_hashmap) {         // 添加到一级 缓存中 
293.link_hashmap.put(key, bitmap); 
294.
295.
296.
297. 
298. 
299./** 在后台 加载每个图片
300.*  第一个参数 第2个要进度条不 第三个返回结果 bitmap
301.*/ 
302.class ImageDownloadTask extends AsyncTask<String, Void, Bitmap> { 
303. 
304.private String key; 
305.private WeakReference<ImageView> imgViReference; 
306. 
307.public ImageDownloadTask(ImageView imageView) { 
308.//imageView 传进来 。。要给哪个iamgeView加载图片 
309.imgViReference = new WeakReference<ImageView>( 
310.imageView); 
311.
312. 
313.@Override 
314.protected Bitmap doInBackground(String... params){ 
315.key = params[0]; 
316.//调用下载函数 根据 url 下载       
317.return downloadBitmap(key); 
318.
319. 
320.@Override 
321.protected void onPostExecute(Bitmap result) { 
322.if(isCancelled()){ 
323.result = null
324.
325. 
326.System.out.println("result=="+ result.getByteCount()+"---memClassmemery="+memClass); 
327. 
328.if(null!= result){ 
329.//保存到缓存中 
330.addBitmap(key, result); 
331.ImageView  imageView = imgViReference.get(); 
332.if( null != imageView){   
333.//向 imageView 里面放入 bitmap          
334.ImageDownloadTask task = getImageDownloadTask(imageView); 
335. 
336./**
337.*  判断 是不是 同一个 task( )
338.*  如果当前这个 task  ==  imageView 里面的那个 task 就是同1个
339.*/ 
340.if( this == task ){ 
341.imageView.setImageBitmap(result); 
342. 
343.
344.
345.
346.
347.
348. 
349. 
350./**
351.* 连接网络 客户端 下载图片
352.*/ 
353.private Bitmap downloadBitmap(String url) { 
354. 
355.final HttpClient client = AndroidHttpClient.newInstance("Android"); 
356.final HttpGet getRequest = new HttpGet(url);  
357.try
358.HttpResponse response = client.execute(getRequest); 
359.final int statusCode = response.getStatusLine().getStatusCode(); 
360. 
361.if (statusCode != HttpStatus.SC_OK) { 
362. 
363.Log.w("ImageDownloader", "Error " + statusCode + " while retrieving bitmap from " + url); 
364.return null
365.
366. 
367.final HttpEntity entity = response.getEntity(); 
368.if (entity != null) { 
369.InputStream inputStream = null
370.try
371. 
372.inputStream = entity.getContent();                  
373./**
374.*  1.没有压缩直接将生成的bitmap返回去
375.*/ 
376.//                  return BitmapFactory.decodeStream(inputStream); 
377. 
378./**
379.*  2.得到data后在这里把图片进行压缩
380.*/ 
381.byte[] data = StreamTool.read(inputStream);  
382.return  BitmapManager.scaleBitmap(context, data, 0.3f); 
383.//                   return BitmapFactory.decodeStream(new FlushedInputStream(inputStream)); 
384.} finally
385.if (inputStream != null) { 
386.inputStream.close(); 
387.
388.entity.consumeContent(); 
389.
390.
391.} catch (IOException e) { 
392.getRequest.abort(); 
393.} catch (IllegalStateException e) { 
394.getRequest.abort(); 
395.} catch (Exception e) { 
396.getRequest.abort(); 
397.} finally
398.if ((client instanceof AndroidHttpClient)) { 
399.((AndroidHttpClient) client).close(); 
400.
401.
402.return null
403.
404. 
405.}


 StreamTool.java

01.public class StreamTool { 
02. 
03.public static  byte[] read(InputStream in) throws Exception{ 
04.ByteArrayOutputStream  out_byte = new ByteArrayOutputStream(); 
05.byte[] buff = new byte[1024]; 
06.int len=0
07.while((len = in.read(buff))!= -1){ 
08.//写到内存中  字节流 
09.out_byte.write( buff, 0 , len); 
10.}    
11.out_byte.close();    
12.// 把内存数据返回 
13.return  out_byte.toByteArray();  
14.
15.}


 BitmapManager.java ( 这个类里面对 网络资源的图片 进行了优化)

001.public class BitmapManager {
002. 
003./**
004.* 按屏幕适配Bitmap
005.*/
006.public static Bitmap scaleBitmap(Context context, byte[] data , float percent) {
007. 
008.//这里我不获取了,假设是下面这个分辨率
009.int screenWidth =   540;
010.int screenrHeight = 950;
011.//设置 options
012.BitmapFactory.Options options = new BitmapFactory.Options();
013./**
014.*  BitmapFactory.Options这个类,有一个字段叫做 inJustDecodeBounds.SDK中对这个成员的说明是这样的:
015.*  If set to true, the decoder will return null (no bitmap), but the out…
016.*  也就是说,如果我们把它设为true,那么BitmapFactory.decodeFile(String path, Options opt)并不会真的返回一个Bitmap给你,
017.*  它仅仅会把它的宽,高取回来给你,这样就不会占用太多的内存,也就不会那么频繁的发生OOM了。
018.*/
019.options.inJustDecodeBounds = true;
020. 
021.//读取
022.Bitmap bitmap = BitmapFactory.decodeByteArray(data, 0, data.length, options);
023. 
024.int imgWidth = options.outWidth;
025.int imgHeight = options.outHeight;
026. 
027.//如果比你设置的宽高大  就进行缩放,
028.if(imgWidth > screenWidth * percent || imgHeight > screenrHeight * percent) {
029.options.inSampleSize = calculateInSampleSize(options, screenWidth, screenrHeight, percent);
030.}
031. 
032. 
033./**
034.* If set to true, the decoder will return null (no bitmap), but the out... fields will still be set, allowing the caller
035.* to query the bitmap without having to allocate the memory for its pixels.
036.*
037.* 如果设置成 true,这个编码将会返回1个null , 但是那个区域仍将被设置(也就是存在),允许(调用者)去查询那个没有分配 内存的像素  bitmap
038.*/
039.options.inJustDecodeBounds = false;
040. 
041./**
042.*  Android的Bitmap.Config给出了bitmap的一个像素所对应的存储方式,
043.*  有RGB_565,ARGB_8888,ARGB_4444,ALPHA_8四种。RGB_565表示的是红绿蓝三色分别用5,6,5个比特来存储,
044.*  一个像素占用了5+6+5=16个比特。ARGB_8888表示红绿蓝和半透明分别用8,8,8,8个比特来存储,
045.*  一个像素占用了8+8+8+8=32个比特。这样的话如果图片是以RGB_8888读入的,那么占用内存的大小将是RGB_565读入方式的2倍。
046.*  通常我们给Imagview加载图片是通过setDrawable或者在
047.*  默认的加载图片大小的方式是以RGB_8888读入的。
048.*
049.*/
050.options.inPreferredConfig = Bitmap.Config.RGB_565;
051. 
052./**
053.* If this is set to true, then the resulting bitmap will allocate its pixels such that they can be purged
054.* if the system needs to reclaim memory.
055.*
056.* 如果设置成 true, 这个结果bitmap 将会被分配像素,这样他们就能被 系统回收了,当系统需要回收内存的时候
057.*/
058.options.inPurgeable = true;
059. 
060./**
061.* This field works in conjuction with inPurgeable.
062.* 这个方法是在   inPurgeable 的基础上工作的
063.*/
064.options.inInputShareable = true;
065. 
066. 
067.bitmap = BitmapFactory.decodeByteArray(data, 0, data.length, options);
068. 
069.System.out.println("data==="+  data.length +"  change == bitmap byte "+ bitmap.getByteCount());
070.return bitmap;
071.}
072. 
073. 
074. 
075.//                                                    options       reqWidth 屏幕宽      reqHeight屏幕高      你的view是屏幕的多大
076.public static int calculateInSampleSize(BitmapFactory.Options options, int screenWidth, int screenHeight ,float percent) {
077. 
078.// 原始图片宽高
079.final int height = options.outHeight;
080.final int width = options.outWidth;
081.// 倍数
082.int inSampleSize = 1;
083. 
084.if (height > screenHeight * percent || width > screenWidth * percent) {
085. 
086.// 计算目标宽高与原始宽高的比值
087.final int inSampleSize_h = Math.round((float) height / (float)( screenHeight * percent));
088. 
089.final int inSampleSize_w = Math.round((float) width / (float)( screenWidth * percent));
090. 
091.// 选择两个比值中较小的作为inSampleSize的
092.inSampleSize = inSampleSize_h < inSampleSize_w ? inSampleSize_h : inSampleSize_w;
093. 
094.System.out.println("inSampleSize===="+ inSampleSize);
095.//
096.if(inSampleSize < 1) {
097.inSampleSize = 1;
098.}
099.}
100.//简单说这个数字就是 缩小为原来的几倍,根据你的image需要占屏幕多大动态算的(比如你用的权重设置layout)
101.return inSampleSize;
102.}
103.}


 这个是代码输出的最多给这个进程分配的内存 128M

可以看到我上面的bitmapManager 里面有个   options.inPreferredConfig   注释写的很清楚,可以上去看一下,接下来贴几种格式的效果图

rgb565  和  argb_444  所占的内存              (54000)

 

看一下 argb_8888                    (  108000)

 

当然可能仔细看的人会看到我一开始截的 鸣人的效果图 上半部分 和 下半部分的颜色会有点问题。上面的rgb_565 生成的,和原图色彩可能会有点出入。

但是内存真心少了一半,所以各种取舍就看个人了,代码注释都谢的很清楚了。

 

至于 : MyImageLoaderLru.java  其实就是    MyImageLoader.java

先贴出代码不同地方的代码 : 就是在强引用的地方  把  LinkedHashMap 换成了 LruCache

 

 01.// 获取单个进程可用内存的最大值 
02.// 方式一:使用ActivityManager服务(计量单位为M) 
03./*int memClass = ((ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE)).getMemoryClass();*/ 
04.// 方式二:使用Runtime类(计量单位为Byte) 
05.final static int memClass = (int) Runtime.getRuntime().maxMemory(); 
06.// 3. 定义一级缓存容器  强引用       (catch_num /2,0.75f,true) 默认参 数                                                                                                                        2.加载因子默认        3.排序模式 true
07.final static int  max = memClass/5;
08. 
09.// LruCache 用强引用将  图片放入     LinkedHashMap
10.private static LruCache<String, Bitmap> lrucache = new LruCache<String, Bitmap>(max) {
11.protected int sizeOf(String key, Bitmap value) { 
12.if(value != null) { 
13.// 计算存储bitmap所占用的字节数 
14.return value.getRowBytes() * value.getHeight(); 
15.} else
16.return 0
17.
18.
19. 
20.@Override 
21.protected void entryRemoved(boolean evicted, String key, Bitmap oldValue, Bitmap newValue) { 
22.if(oldValue != null) { 
23.// 当硬引用缓存容量已满时,会使用LRU算法将最近没有被使用的图片转入软引用缓存 
24.current_hashmap.put(key, new SoftReference<Bitmap>(oldValue)); 
25.
26.
27.};


1. 强引用:LruCache 后面再说,其实他内的内部封装的就是1个 LinkedHashMap 。LinkedHashMap 是线程不安全的,所以上面都会用到同步。

2. 软引用:ConcurrentHashMap 是线程安全的,并且支持高并发很有效率,这个后面也会说到,为什么要用 软引用 SoftReference,这个是在系统将要oom时,就会回收

                    软引用的对象资源,所以才会用到他,防止程序出异常 。

3. 磁盘缓存: 这个经常会看到网易新闻等,应用有些界面你看了很多图片,往上翻很多, 其实没有再次访问网络,会将部分image缓存在sdcard里。

4. 其中1个优化: 当比如用户快速滑动到 最底部,其实是最先加载显示给用户的部分的内容的,这样就是用户看到哪加载哪,1个是快,1个是避免资源浪费。

 

原理: 当用户进入界面加载图片 ,首先会从1级缓存强引用中找,找不到回去2级缓存软引用中找,找不到再去sdcard中找,再找不到才会去请求网络加载资源。

            当然sdcard的缓存 看个人需求是否需要。

 

注: android 4.0 后 对 SoftReference 的回收机制进行了改变,所以你是可以不用 2级缓存的,直接去掉就好了。

          只要控制好你的 lrucache 或者 linkedhashmap就好了。

免费培训课:http://www.jinhusns.com/Products/Curriculum/?type=xcj