在Android中经常性的会用到加载图片的问题，那么为了不阻塞主线程，我们首先要考虑异步操作，为了用户更好地体验我们还需要考虑对图片进行缓存。

对图片进行缓存首先要了解softreference<Bitmap>软存储机制，还有就是硬存储的方式在手机端一般就是SD卡的存储。

那么如果当我们进行图片异步加载的时候就需要考虑内存中是否有，如果内存中有的话直接从内存中取出，如果内存中没有的话，再从网上去下载。

判断内存中是否有图片要先从softreference中判断,如果没有就从SD卡中读取，如果两者都没有则从网上下载

ImgLoader.java

        
                
  1. packagecom.SQLiteTest; 
    2.             
    3.             
  3. importjava.io.FileInputStream; 
    4.             
  4. importjava.lang.ref.SoftReference; 
    5.             
  5. importjava.util.Map; 
    6.             
  6. importandroid.content.Context; 
    7.             
  7. importandroid.graphics.Bitmap; 
    8.             
  8. importandroid.graphics.BitmapFactory; 
    9.             
  9. importandroid.os.Environment; 
    10.             
    11.             
  11. publicclassPicManager{ 
    12.             
  12. privateContextcontext; 
    13.             
  13. privateMap<String,SoftReference<Bitmap>>imgCache; 
    14.             
  14. privateFileUtilsfUtils=newFileUtils(); 
    15.             
  15.  
    16.             
  16. /* 
    17.             
  17. *构造函数 
    18.             
  18. */
    19.             
  19. publicPicManager(Contextcontext, 
    20.             
  20. Map<String,SoftReference<Bitmap>>imgCache){ 
    21.             
  21. super(); 
    22.             
  22. this.context=context; 
    23.             
  23. this.imgCache=imgCache; 
    24.             
  24. } 
    25.             
  25.  
    26.             
  26. /* 
    27.             
  27. *先从缓存中读取，如果没有的话从文件读取 
    28.             
  28. */
    29.             
  29.  
    30.             
  30. publicBitmapgetFromCache(Stringurl) 
    31.             
  31. { 
    32.             
  32. Bitmapbit=null; 
    33.             
  33. if(imgCache.containsKey(url)) 
    34.             
  34. { 
    35.             
  35.  
    36.             
  36. synchronized(imgCache){ 
    37.             
  37. SoftReference<Bitmap>bitReference=imgCache.get(url); 
    38.             
  38. if(bitReference!=null) 
    39.             
  39. { 
    40.             
  40. bit=bitReference.get(); 
    41.             
  41. } 
    42.             
  42.  
    43.             
  43. } 
    44.             
  44.  
    45.             
  45. } 
    46.             
  46. else{ 
    47.             
  47. bit=getFromSDcard(url); 
    48.             
  48. imgCache.put(url,newSoftReference<Bitmap>(bit)); 
    49.             
  49. } 
    50.             
  50. returnbit; 
    51.             
  51. } 
    52.             
  52.  
    53.             
  53. privateBitmapgetFromSDcard(Stringurl) 
    54.             
  54. { 
    55.             
  55.  
    56.             
  56. Bitmapbitmap=null; 
    57.             
  57.  
    58.             
  58. Stringfilename=fUtils.getFName(url); 
    59.             
  59.  
    60.             
  60. System.out.println("PicManager-->"+filename); 
    61.             
  61. Stringpath=Environment.getExternalStorageDirectory()+"/"; 
    62.             
  62. try{ 
    63.             
  63. FileInputStreamfis=context.openFileInput(path+"picture/"+filename); 
    64.             
  64. //FileInputStreamfis=newFileInputStream(path+"picture"+filename); 
    65.             
  65. bitmap=BitmapFactory.decodeStream(fis); 
    66.             
  66. fis.close(); 
    67.             
  67. }catch(Exceptione){ 
    68.             
  68. //TODOAuto-generatedcatchblock 
    69.             
  69. e.printStackTrace(); 
    70.             
  70. } 
    71.             
  71. returnbitmap; 
    72.             
  72. } 
    73.             
  73. } 
    74.

PicManager.java

        
                
  1. packagecom.SQLiteTest; 
    2.             
    3.             
  3. importjava.lang.ref.SoftReference; 
    4.             
  4. importjava.util.HashMap; 
    5.             
  5. importjava.util.Map; 
    6.             
  6. importjava.util.concurrent.ExecutorService; 
    7.             
  7. importjava.util.concurrent.Executors; 
    8.             
    9.             
  9. importandroid.content.Context; 
    10.             
  10. importandroid.graphics.Bitmap; 
    11.             
  11. importandroid.graphics.BitmapFactory; 
    12.             
  12. importandroid.os.Handler; 
    13.             
    14.             
  14. publicclassImgLoader{ 
    15.             
  15.  
    16.             
  16. privateContextcontext; 
    17.             
  17. finalMap<String,SoftReference<Bitmap>>imgCache= 
    18.             
  18. newHashMap<String,SoftReference<Bitmap>>(); 
    19.             
  19.  
    20.             
  20. publicImgLoader(Contextcontext){ 
    21.             
  21. super(); 
    22.             
  22. this.context=context; 
    23.             
  23. } 
    24.             
  24.  
    25.             
  25. privateHandlermhandler=newHandler(); 
    26.             
  26. privatePicManagerpm=newPicManager(context,imgCache); 
    27.             
  27. privateFileUtilsfuUtils=newFileUtils(); 
    28.             
  28. privateExecutorServicethreadPool=Executors.newFixedThreadPool(5); 
    29.             
  29. privateDownLoaddl=newDownLoad(); 
    30.             
  30.  
    31.             
  31. publicBitmaploadImg(finalStringurl,finalImgCallBackcallBack) 
    32.             
  32. { 
    33.             
  33. Bitmapbitmap=null; 
    34.             
  34. try{ 
    35.             
  35.  
    36.             
  36. bitmap=pm.getFromCache(url); 
    37.             
  37. System.out.println("ImgLoader--->执行？？？"); 
    38.             
  38. if(bitmap==null) 
    39.             
  39. { 
    40.             
  40. System.out.println("ImgLoader--->什么时候执行"); 
    41.             
  41. threadPool.submit(newRunnable(){ 
    42.             
  42.  
    43.             
  43. @Override
    44.             
  44. publicvoidrun(){ 
    45.             
  45. //TODOAuto-generatedmethodstub 
    46.             
  46. Stringfname=fuUtils.getFName(url); 
    47.             
  47.  
    48.             
  48. dl.download(url,"picture/",fname); 
    49.             
  49. finalBitmapbit=BitmapFactory.decodeStream(dl.getInput(url)); 
    50.             
  50. //imgCache.put(url,newSoftReference<Bitmap>(bit)); 
    51.             
  51. mhandler.post(newRunnable(){ 
    52.             
  52.  
    53.             
  53. @Override
    54.             
  54. publicvoidrun(){ 
    55.             
  55. //TODOAuto-generatedmethodstub 
    56.             
  56.  
    57.             
  57. callBack.refresh(bit); 
    58.             
  58. } 
    59.             
  59. }); 
    60.             
  60. } 
    61.             
  61.  
    62.             
  62.  
    63.             
  63. }); 
    64.             
  64. } 
    65.             
  65. }catch(Exceptione){ 
    66.             
  66. //TODO:handleexception 
    67.             
  67. } 
    68.             
  68.  
    69.             
  69. returnbitmap; 
    70.             
  70. } 
    71.             
  71.  
    72.             
  72. } 
    73.

DownLoad.java

        
                
  1. packagecom.SQLiteTest; 
    2.             
    3.             
  3. importjava.io.InputStream; 
    4.             
  4. importjava.net.HttpURLConnection; 
    5.             
  5. importjava.net.URL; 
    6.             
    7.             
  7. publicclassDownLoad{ 
    8.             
  8.  
    9.             
  9.  
    10.             
  10. publicvoiddownload(Stringurl,Stringpath,Stringfilename) 
    11.             
  11. { 
    12.             
  12. FileUtilsfUtils=newFileUtils(); 
    13.             
  13. InputStreaminput=null; 
    14.             
  14.  
    15.             
  15. if(!fUtils.isExist(filename)) 
    16.             
  16. { 
    17.             
  17. try 
    18.             
  18. { 
    19.             
  19. input=getInput(url); 
    20.             
  20. System.out.println("DownLoad--->"+input); 
    21.             
  21. fUtils.write2SDCARD(path,filename,input); 
    22.             
  22.  
    23.             
  23. }catch(Exceptione){ 
    24.             
  24. //TODOAuto-generatedcatchblock 
    25.             
  25. e.printStackTrace(); 
    26.             
  26. } 
    27.             
  27.  
    28.             
  28.  
    29.             
  29. } 
    30.             
  30.  
    31.             
  31.  
    32.             
  32. } 
    33.             
  33.  
    34.             
  34. publicInputStreamgetInput(Stringurlstr) 
    35.             
  35. { 
    36.             
  36. URLurl=null; 
    37.             
  37. InputStreaminput=null; 
    38.             
  38. try{ 
    39.             
  39. url=newURL(urlstr); 
    40.             
  40. HttpURLConnectionhul=(HttpURLConnection)url.openConnection(); 
    41.             
  41. input=hul.getInputStream(); 
    42.             
  42. }catch(Exceptione){ 
    43.             
  43. //TODOAuto-generatedcatchblock 
    44.             
  44. e.printStackTrace(); 
    45.             
  45. } 
    46.             
  46.  
    47.             
  47. returninput; 
    48.             
  48. } 
    49.             
  49. } 
    50.

FileUtilts.java

        
                
  1. packagecom.SQLiteTest; 
    2.             
    3.             
  3. importjava.io.File; 
    4.             
  4. importjava.io.FileOutputStream; 
    5.             
  5. importjava.io.InputStream; 
    6.             
  6. importjava.io.OutputStream; 
    7.             
    8.             
  8. importandroid.os.Environment; 
    9.             
    10.             
  10. publicclassFileUtils{ 
    11.             
  11.  
    12.             
  12. privateStringSDPATH=Environment.getExternalStorageDirectory()+"/"; 
    13.             
  13.  
    14.             
  14. publicFilecreaPath(Stringpath) 
    15.             
  15. { 
    16.             
  16. Filefile=newFile(SDPATH+path); 
    17.             
  17. file.mkdir(); 
    18.             
  18. returnfile; 
    19.             
  19. } 
    20.             
  20.  
    21.             
  21. publicFilecreaFile(StringfileName)throwsException 
    22.             
  22. { 
    23.             
  23. Filef=newFile(SDPATH+fileName); 
    24.             
  24. f.createNewFile(); 
    25.             
  25. returnf; 
    26.             
  26. } 
    27.             
  27.  
    28.             
  28. publicbooleanisExist(StringFilename) 
    29.             
  29. { 
    30.             
  30. Filef=newFile(SDPATH+Filename); 
    31.             
  31. returnf.exists(); 
    32.             
  32. } 
    33.             
  33.  
    34.             
  34. publicvoidwrite2SDCARD(Stringpath,Stringfilename,InputStreaminput) 
    35.             
  35. { 
    36.             
  36.  
    37.             
  37. try{ 
    38.             
  38. creaPath(path); 
    39.             
  39. Filefile=creaFile(path+filename); 
    40.             
  40.  
    41.             
  41. OutputStreamoutput=newFileOutputStream(file); 
    42.             
  42. byte[]buffer=newbyte[4*1024]; 
    43.             
  43. intline=0; 
    44.             
  44. while((line=input.read(buffer))!=-1) 
    45.             
  45. { 
    46.             
  46. output.write(buffer,0,line); 
    47.             
  47.  
    48.             
  48. } 
    49.             
  49. output.flush(); 
    50.             
  50. output.close(); 
    51.             
  51.  
    52.             
  52. }catch(Exceptione){ 
    53.             
  53. //TODOAuto-generatedcatchblock 
    54.             
  54. e.printStackTrace(); 
    55.             
  55. } 
    56.             
  56.  
    57.             
  57. } 
    58.             
  58.  
    59.             
  59. publicStringgetFName(Stringurl) 
    60.             
  60. { 
    61.             
  61. intstart=url.lastIndexOf("/"); 
    62.             
  62.  
    63.             
  63. Stringstr=url.substring(start); 
    64.             
  64. returnstr; 
    65.             
  65. } 
    66.             
  66.  
    67.             
  67.  
    68.             
  68. } 
    69.

ImgCallBack.java

这是个接口主要负责刷新Bitmap

        
                
  1. packagecom.SQLiteTest; 
    2.             
    3.             
  3. importandroid.graphics.Bitmap; 
    4.             
    5.             
  5. publicinterfaceImgCallBack{ 
    6.             
  6.  
    7.             
  7. publicvoidrefresh(Bitmapbitmap); 
    8.             
  8.  
    9.             
  9. } 
    10.

更多相关文章

  1. android 获取网络图片缓存（内存—>文件—>网络）
  2. Android(安卓)中 Activity的内存泄漏，原因以及处理方法
  3. ANDROID 探究oom内幕
  4. Android加载Bitmap出现OutofMemoryError的原因（官方译文）
  5. Android防止内存泄露
  6. android中Bitmap导致的内存溢出
  7. Android的内存，进程调度管理
  8. 利用WCF与Android实现图片上传并传参
  9. 安卓开发工程师必备技能——框架，看看你都掌握了哪些

随机推荐

  1. 为什么深度学习没有取代传统的计算机视觉
  2. Playwright自动化测试工具之高阶使用
  3. 一个数据开发人员使用的辅助工具
  4. 利用 npm 的缺陷，他获得了 130,000 美元的
  5. Python可以比C++更快，你不信？
  6. 求求你，别用 print 来 debug 了
  7. 谷歌推出人工智能DIY套件：用硬纸板打造你
  8. 谁来接棒深度学习？
  9. IBM推出开源工具帮AI抵御对抗性样本***：DN
  10. 苹果重新开源分布式数据库FoundationDB，已