Android缓存提高性能的方法

最新推荐文章于 2022-04-28 15:35:40 发布
最新推荐文章于 2022-04-28 15:35:40 发布
阅读量3.6k 收藏 1
点赞数
分类专栏： Android开发详解 文章标签： android开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/he90227/article/details/39157661
版权

1.android用存到缓存的方法来保存ListView里的数据

对于这样的数据：

[html] view plaincopyprint?
  1. <?xml version="1.0" encoding="utf-8" ?> 
  2. <rss><sid>77f265bb46de068e78f35afbadec62af</sid><count>3</count><control>0</control> 
  3. <mblog><uid>1195224593</uid><favid>3436952795</favid><mblogid>5xtaJR</mblogid><mblogidnum>3436952795</mblogidnum><mblogtype>0</mblogtype><mlevel>0</mlevel><feedid>5xtaJR</feedid><nick>马艳丽</nick><portrait>http://tp2.sinaimg.cn/1195224593/50/5614100014/0</portrait><vip>1</vip><vipsubtype>0</vipsubtype><member_type>13</member_type><remark></remark><level>2</level><rtnum>11</rtnum><commentnum>25</commentnum><attitudenum>0</attitudenum><attitudeid>0</attitudeid><attitudes_status>0</attitudes_status><attitudes_count>0</attitudes_count><mblogtypename></mblogtypename><visible><type>0</type><list_id>0</list_id></visible><content>婚礼在北海美丽的北海公园举行…好美好浪漫的地方… </content><pic>http://ss12.sinaimg.cn/wap240/473dae11494344debfc5b</pic><time>1288852274</time><source>彩信</source></mblog></rss> 
[html]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. <?xml version="1.0" encoding="utf-8" ?>  
  2. <rss><sid>77f265bb46de068e78f35afbadec62af</sid><count>3</count><control>0</control>  
  3. <mblog><uid>1195224593</uid><favid>3436952795</favid><mblogid>5xtaJR</mblogid><mblogidnum>3436952795</mblogidnum><mblogtype>0</mblogtype><mlevel>0</mlevel><feedid>5xtaJR</feedid><nick>马艳丽</nick><portrait>http://tp2.sinaimg.cn/1195224593/50/5614100014/0</portrait><vip>1</vip><vipsubtype>0</vipsubtype><member_type>13</member_type><remark></remark><level>2</level><rtnum>11</rtnum><commentnum>25</commentnum><attitudenum>0</attitudenum><attitudeid>0</attitudeid><attitudes_status>0</attitudes_status><attitudes_count>0</attitudes_count><mblogtypename></mblogtypename><visible><type>0</type><list_id>0</list_id></visible><content>婚礼在北海美丽的北海公园举行…好美好浪漫的地方… </content><pic>http://ss12.sinaimg.cn/wap240/473dae11494344debfc5b</pic><time>1288852274</time><source>彩信</source></mblog></rss>  


首先我们把从服务器取到的数据，里面有个主要的对象mblog,我们用一个对象来存储:

[java] view plaincopyprint?
  1. public class MBlog implements <strong>Serializable</strong> {  //保证这个对象是可以序列化的 
  2.     private static final long serialVersionUID = -3514924369786543050L; 
  3.     public String uid; 
  4.     public String favid; 
  5.     public String mblogid; 
  6.     public String nick; 
  7.     public String portrait; 
  8.     public boolean vip; 
  9.     public String content; 
  10.     public String rtrootuid; 
  11.     public String rtrootid; 
  12.     public String rtrootnick; 
  13.     public boolean rtrootvip; 
  14.     public String rtreason; 
  15.     public int rtnum; 
  16.     public int commentnum; 
  17.     public Date time; 
  18.     public String pic; 
  19.     public String src; 
  20.     public String longitude;// 经度 
  21.     public String latitude;// 纬度 
  22.  
  23.     public boolean equals(Object o) { 
  24.         if (o == null) return false; 
  25.         if (o == this) return true; 
  26.         Class<?> cla = o.getClass(); 
  27.         if (cla == getClass()) { 
  28.             MBlog other = (MBlog) o; 
  29.             if (other.mblogid.equals(mblogid)) return true; 
  30.         } 
  31.         return false; 
  32.     } 
  33.  
  34.     public int hashCode() { 
  35.         return mblogid.hashCode() * 101 >> 12; 
  36.     } 
  37.  
  38.  
  39. } 
[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. public class MBlog implements <strong>Serializable</strong> {  //保证这个对象是可以序列化的  
  2.     private static final long serialVersionUID = -3514924369786543050L;  
  3.     public String uid;  
  4.     public String favid;  
  5.     public String mblogid;  
  6.     public String nick;  
  7.     public String portrait;  
  8.     public boolean vip;  
  9.     public String content;  
  10.     public String rtrootuid;  
  11.     public String rtrootid;  
  12.     public String rtrootnick;  
  13.     public boolean rtrootvip;  
  14.     public String rtreason;  
  15.     public int rtnum;  
  16.     public int commentnum;  
  17.     public Date time;  
  18.     public String pic;  
  19.     public String src;  
  20.     public String longitude;// 经度  
  21.     public String latitude;// 纬度  
  22.   
  23.     public boolean equals(Object o) {  
  24.         if (o == null) return false;  
  25.         if (o == this) return true;  
  26.         Class<?> cla = o.getClass();  
  27.         if (cla == getClass()) {  
  28.             MBlog other = (MBlog) o;  
  29.             if (other.mblogid.equals(mblogid)) return true;  
  30.         }  
  31.         return false;  
  32.     }  
  33.   
  34.     public int hashCode() {  
  35.         return mblogid.hashCode() * 101 >> 12;  
  36.     }  
  37.   
  38.   
  39. }  

在Activity取到缓存的Path:  mCacheDir = this.getCacheDir().getPath();

一般是/data/data/com.example.weibotest/cache


这个是save方法:

[java] view plaincopyprint ?
  1. public static void save(Object obj, String path) { 
  2.     try { 
  3.         File f = new File(path); 
  4.         /*if(f != null){
  5.             f.mkdirs();
  6.             f.createNewFile();
  7.         }*/ 
  8.         FileOutputStream fos = new FileOutputStream(f); 
  9.         ObjectOutputStream oos = new ObjectOutputStream(fos); 
  10.         oos.writeObject(obj); 
  11.         oos.flush(); 
  12.         oos.close(); 
  13.     } 
  14.     catch (IOException e) { 
  15.     } 
  16. } 
[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. public static void save(Object obj, String path) {  
  2.     try {  
  3.         File f = new File(path);  
  4.         /*if(f != null){ 
  5.             f.mkdirs(); 
  6.             f.createNewFile(); 
  7.         }*/  
  8.         FileOutputStream fos = new FileOutputStream(f);  
  9.         ObjectOutputStream oos = new ObjectOutputStream(fos);  
  10.         oos.writeObject(obj);  
  11.         oos.flush();  
  12.         oos.close();  
  13.     }  
  14.     catch (IOException e) {  
  15.     }  
  16. }  


读取方法:

[java] view plaincopyprint?
  1. public static Object load(String path) { 
  2.     Object obj = null; 
  3.     File file = new File(path); 
  4.     try { 
  5.         /*if(file != null){
  6.             file.mkdirs();
  7.         }*/ 
  8.         if (file.exists()) { 
  9.             FileInputStream fis = new FileInputStream(file); 
  10.             ObjectInputStream ois = new ObjectInputStream(fis); 
  11.             try { 
  12.                 obj = ois.readObject(); 
  13.             } 
  14.             catch (ClassNotFoundException e) { 
  15.             } 
  16.             ois.close(); 
  17.         }    
  18.     }catch (IOException e) { 
  19.         } 
  20.     return obj; 
  21. } 
[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. public static Object load(String path) {  
  2.     Object obj = null;  
  3.     File file = new File(path);  
  4.     try {  
  5.         /*if(file != null){ 
  6.             file.mkdirs(); 
  7.         }*/  
  8.         if (file.exists()) {  
  9.             FileInputStream fis = new FileInputStream(file);  
  10.             ObjectInputStream ois = new ObjectInputStream(fis);  
  11.             try {  
  12.                 obj = ois.readObject();  
  13.             }  
  14.             catch (ClassNotFoundException e) {  
  15.             }  
  16.             ois.close();  
  17.         }     
  18.     }catch (IOException e) {  
  19.         }  
  20.     return obj;  
  21. }  

这样来调用:

[java] view plaincopyprint?
  1. public void parseAssertData() { 
  2.         InputStream is = null; 
  3.         try { 
  4.             is = this.getAssets().open("11.xml", Context.MODE_PRIVATE); 
  5.             int length = is.available(); 
  6.             byte[] buffer = new byte[length]; 
  7.             is.read(buffer); 
  8.             String temp = new String(buffer); 
  9.  
  10.             try { 
  11.                 Object[] array = ParseData.getMBlogList(temp); 
  12.                 List<MBlog> list = (List<MBlog>)array[1]; 
  13.                 FileUtils.save(list, mCacheDir+'/'+"001_fav"); 
  14.                  
  15.                  
  16.                 List<MBlog> list1 = (List<MBlog>)FileUtils.load(mCacheDir+'/'+"001_fav"); 
  17.                 MBlog blog = list1.get(1); 
  18.                 System.out.println("===size="+blog.src); 
  19.             } catch (Exception e) { 
  20.                 e.printStackTrace(); 
  21.             } 
  22.              
  23.         } catch (IOException ex) { 
  24.             ex.printStackTrace(); 
  25.         } 
  26.     } 
[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. public void parseAssertData() {  
  2.         InputStream is = null;  
  3.         try {  
  4.             is = this.getAssets().open("11.xml", Context.MODE_PRIVATE);  
  5.             int length = is.available();  
  6.             byte[] buffer = new byte[length];  
  7.             is.read(buffer);  
  8.             String temp = new String(buffer);  
  9.   
  10.             try {  
  11.                 Object[] array = ParseData.getMBlogList(temp);  
  12.                 List<MBlog> list = (List<MBlog>)array[1];  
  13.                 FileUtils.save(list, mCacheDir+'/'+"001_fav");  
  14.                   
  15.                   
  16.                 List<MBlog> list1 = (List<MBlog>)FileUtils.load(mCacheDir+'/'+"001_fav");  
  17.                 MBlog blog = list1.get(1);  
  18.                 System.out.println("===size="+blog.src);  
  19.             } catch (Exception e) {  
  20.                 e.printStackTrace();  
  21.             }  
  22.               
  23.         } catch (IOException ex) {  
  24.             ex.printStackTrace();  
  25.         }  
  26.     }  


2、Android使用缓存优化ListView


ListView调用Adapter的getView方法获取每一个Item布局，将这些已经获得的Item布局放入缓存，将大大提高获取数据的效率，而且节省更多的流量，将数据进行缓存有两种方法是，一种是将内存缓存一种是sd卡缓存，在此分别进行演示。

sd卡缓存：

sd卡缓存是将下载的数据保存到sd卡中，当再次要获取数据时，首先要判断sd卡中是否存在，如果存在的话，就直接读取sd卡中的数据，如果不存在就从网上下载，然后保存到sd卡中

内存缓存：

内存优化是将获取到的数据存取到Map集合中，如果再次引用此数据，就直接从Map集合中获取，这样会导致一个问题，如果Map集合中的数据特别多，比如存取了100万条数据，这样有可能就会导致内存溢出。这是因为Map集合是强引用的集合，如何不把Map集合置为空的话，这个集合Java虚拟机就不会把它回收掉，当Map中的数据大小超过了内存大小就会导致内存溢出。为了避免这种异常我们要使用软引用softreference ，软引用和强引用的区别如下：

1. softreference 他是java虚拟机给我们提供的一个包装类型.
在包装类型里面的对象 一般情况下 ,java虚拟机会尽量长时间的保留这个对象
当java虚拟机内存不足的时候 java虚拟机就会回收 softreference里面的对象


2. hardreference  默认new出来的对象 都是这种强应用的类型
只要一个对象还保留的有引用,他就不会被垃圾回收
Map<String,Bitmap> map;

 

核心代码：

sd卡缓存

[java]  view plain copy
  1. public class MyReadAdapter extends BaseAdapter{  
  2.     private List<CollectionEntry> entrys;  
  3.   
  4.     public MyReadAdapter(CollectionFeed feeds) {  
  5.         entrys = feeds.getEntries();  
  6.     }  
  7.   
  8.     public int getCount() {  
  9.         return entrys.size();  
  10.     }  
  11.   
  12.     public Object getItem(int position) {  
  13.         return entrys.get(position);  
  14.     }  
  15.   
  16.     public long getItemId(int position) {  
  17.         return position;  
  18.     }  
  19.   
  20.     public View getView(int position, View convertView, ViewGroup parent) {  
  21.         View view = infalter.inflate(R.layout.myread_item, null);  
  22.         final ImageView iv =  (ImageView) view.findViewById(R.id.book_img);  
  23.           
  24.         //获取数据实体  
  25.         CollectionEntry ce = entrys.get(position);  
  26.         //获取图片地址  
  27.         String iconurl = ce.getSubjectEntry().getLink("image", null).getHref();  
  28.         int start = iconurl.lastIndexOf("/");  
  29.         int end = iconurl.length();  
  30.         final String iconname = iconurl.substring(start, end);  
  31.         //Environment.getExternalStorageDirectory()这个是sd卡目录  
  32.         File file = new File(Environment.getExternalStorageDirectory(),iconname);  
  33.           
  34.         //获取sd卡缓存  
  35.         if(file.exists()){  
  36.             iv.setImageURI(Uri.fromFile(file));  
  37.             Log.i(TAG,"使用sd卡图片");  
  38.         }else{  
  39.             new LoadImageAsynTask(new ImageTaskCallback() {  
  40.             // 图片获取之后  
  41.             public void onImageLoaded(Bitmap bitmap) {  
  42.                 if(bitmap!=null){  
  43.                 iv.setImageBitmap(bitmap);  
  44.                   
  45.                 //把图片存到sd卡上   
  46.                 if(Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)){  
  47.                     try {  
  48.                         File file = new File(Environment.getExternalStorageDirectory(),iconname);  
  49.                         FileOutputStream fos = new FileOutputStream(file);  
  50.                         bitmap.compress(CompressFormat.JPEG, 100, fos);  
  51.                     } catch (Exception e) {  
  52.                         e.printStackTrace();  
  53.                     }  
  54.                 }  
  55.                 }else{  
  56.                     iv.setImageResource(R.drawable.book);  
  57.                 }  
  58.             }  
  59.             //图片获取之前  
  60.             public void beforeImageLoaded() {  
  61.                 iv.setImageResource(R.drawable.book);  
  62.             }  
  63.         }).execute(iconurl);  
  64.         }  
  65.         return view;  
  66.     }  
  67.       
  68. }  


 

内存缓存

[java]  view plain copy
  1. Map<String,SoftReference<Bitmap>> map;  
  2. public class MyReadAdapter extends BaseAdapter{  
  3.     private List<CollectionEntry> entrys;  
  4.   
  5.     public MyReadAdapter(CollectionFeed feeds) {  
  6.         entrys = feeds.getEntries();  
  7.     }  
  8.   
  9.     public int getCount() {  
  10.         return entrys.size();  
  11.     }  
  12.   
  13.     public Object getItem(int position) {  
  14.         return entrys.get(position);  
  15.     }  
  16.   
  17.     public long getItemId(int position) {  
  18.         return position;  
  19.     }  
  20.   
  21.     public View getView(int position, View convertView, ViewGroup parent) {  
  22.         View view = infalter.inflate(R.layout.myread_item, null);  
  23.         final ImageView iv =  (ImageView) view.findViewById(R.id.book_img);  
  24.         //获取到数据的实体  
  25.         CollectionEntry ce = entrys.get(position);  
  26.         //获取到图片的Url  
  27.         String iconurl = ce.getSubjectEntry().getLink("image", null).getHref();  
  28.         int start = iconurl.lastIndexOf("/");  
  29.         int end = iconurl.length();  
  30.         final String iconname = iconurl.substring(start, end);  
  31.           
  32.         //使用内存缓存  
  33.         if(map!=null && map.get(iconname)!=null){  
  34.             iv.setImageBitmap(map.get(iconname).get());  
  35.             Log.i(TAG,"使用内存缓存");  
  36.         }  
  37.         else{  
  38.         new LoadImageAsynTask(new ImageTaskCallback() {  
  39.             // 图片获取之后  
  40.             public void onImageLoaded(Bitmap bitmap) {  
  41.                 if(bitmap!=null){  
  42.                 iv.setImageBitmap(bitmap);  
  43.                   
  44.                 //存放到内存中,  
  45.                 //软引用类型的bitmap  
  46.                 map.put(iconname, new SoftReference<Bitmap>(bitmap));  
  47.                 }else{  
  48.                     iv.setImageResource(R.drawable.book);  
  49.                 }  
  50.             }  
  51.             //图片获取之前  
  52.             public void beforeImageLoaded() {  
  53.                 iv.setImageResource(R.drawable.book);  
  54.             }  
  55.         }).execute(iconurl);  
  56.         }  
  57.         return view;  
  58.     }  
  59. }  

3、android ListView异步加载图片（双缓存）


对于ListView，相信很多人都很熟悉，因为确实太常见了，所以，做的用户体验更好，就成了我们的追求。。。


常见的ListView中很少全是文字的，一般都是图文共存的，而图片的来源是服务器端（很少有写在客户端的吧。。。考虑客户端的大小和更新的问题），所以，网络问题就成了图片是否能顺利加载成功的决定性因素了。大家都知道每次启动一个Android应用，都会启动一个UI主线程，主要是响应用户的交互，如果我们把不确定的获取网络图片的操作放在UI主线程，结果也就不确定了。。。当然，如果你网络足够好的话，应该问题不大，但是，网络谁能保证呢？所以就出现了“异步加载”的方法！


我先叙述一下异步加载的原理，说的通俗一点就是UI主线程继续做与用户交互的响应监听和操作，而加载图片的任务交到其他线程中去做，当图片加载完成之后，再跟据某种机制（比如回调）绘制到要显示的控件中。


首先，贴出AsyncBitmapLoader.java，这个类是关键，主要做的就是当加载图片的时候，去缓冲区查找，如果有的话，则立刻返回Bitmap对象，省掉再去网络服务器下载的时间和流量。


[java]  view plain copy print ?
  1. <span style="font-size:18px;">package onerain.ald.async;  
  2.   
  3. import java.io.File;  
  4. import java.io.FileNotFoundException;  
  5. import java.io.FileOutputStream;  
  6. import java.io.IOException;  
  7. import java.io.InputStream;  
  8. import java.lang.ref.SoftReference;  
  9. import java.util.HashMap;  
  10.   
  11. import onerain.ald.common.HttpUtils;  
  12. import android.graphics.Bitmap;  
  13. import android.graphics.BitmapFactory;  
  14. import android.os.Handler;  
  15. import android.os.Message;  
  16. import android.widget.ImageView;  
  17.   
  18. /** 
  19.  * @author oneRain 
  20.  **/  
  21. public class AsyncBitmapLoader  
  22. {  
  23.     /** 
  24.      * 内存图片软引用缓冲 
  25.      */  
  26.     private HashMap<String, SoftReference<Bitmap>> imageCache = null;  
  27.       
  28.     public AsyncBitmapLoader()  
  29.     {  
  30.         imageCache = new HashMap<String, SoftReference<Bitmap>>();  
  31.     }  
  32.       
  33.     public Bitmap loadBitmap(final ImageView imageView, final String imageURL, final ImageCallBack imageCallBack)  
  34.     {  
  35.         //在内存缓存中，则返回Bitmap对象  
  36.         if(imageCache.containsKey(imageURL))  
  37.         {  
  38.             SoftReference<Bitmap> reference = imageCache.get(imageURL);  
  39.             Bitmap bitmap = reference.get();  
  40.             if(bitmap != null)  
  41.             {  
  42.                 return bitmap;  
  43.             }  
  44.         }  
  45.         else  
  46.         {  
  47.             /** 
  48.              * 加上一个对本地缓存的查找 
  49.              */  
  50.             String bitmapName = imageURL.substring(imageURL.lastIndexOf("/") + 1);  
  51.             File cacheDir = new File("/mnt/sdcard/test/");  
  52.             File[] cacheFiles = cacheDir.listFiles();  
  53.             int i = 0;  
  54.             for(; i<cacheFiles.length; i++)  
  55.             {  
  56.                 if(bitmapName.equals(cacheFiles[i].getName()))  
  57.                 {  
  58.                     break;  
  59.                 }  
  60.             }  
  61.               
  62.             if(i < cacheFiles.length)  
  63.             {  
  64.                 return BitmapFactory.decodeFile("/mnt/sdcard/test/" + bitmapName);  
  65.             }  
  66.         }  
  67.           
  68.         final Handler handler = new Handler()  
  69.         {  
  70.             /* (non-Javadoc) 
  71.              * @see android.os.Handler#handleMessage(android.os.Message) 
  72.              */  
  73.             @Override  
  74.             public void handleMessage(Message msg)  
  75.             {  
  76.                 // TODO Auto-generated method stub  
  77.                 imageCallBack.imageLoad(imageView, (Bitmap)msg.obj);  
  78.             }  
  79.         };  
  80.           
  81.         //如果不在内存缓存中，也不在本地（被jvm回收掉），则开启线程下载图片  
  82.         new Thread()  
  83.         {  
  84.             /* (non-Javadoc) 
  85.              * @see java.lang.Thread#run() 
  86.              */  
  87.             @Override  
  88.             public void run()  
  89.             {  
  90.                 // TODO Auto-generated method stub  
  91.                 InputStream bitmapIs = HttpUtils.getStreamFromURL(imageURL);  
  92.                   
  93.                 Bitmap bitmap = BitmapFactory.decodeStream(bitmapIs);  
  94.                 imageCache.put(imageURL, new SoftReference<Bitmap>(bitmap));  
  95.                 Message msg = handler.obtainMessage(0, bitmap);  
  96.                 handler.sendMessage(msg);  
  97.                   
  98.                 File dir = new File("/mnt/sdcard/test/");  
  99.                 if(!dir.exists())  
  100.                 {  
  101.                     dir.mkdirs();  
  102.                 }  
  103.                   
  104.                 File bitmapFile = new File("/mnt/sdcard/test/" +   
  105.                         imageURL.substring(imageURL.lastIndexOf("/") + 1));  
  106.                 if(!bitmapFile.exists())  
  107.                 {  
  108.                     try  
  109.                     {  
  110.                         bitmapFile.createNewFile();  
  111.                     }  
  112.                     catch (IOException e)  
  113.                     {  
  114.                         // TODO Auto-generated catch block  
  115.                         e.printStackTrace();  
  116.                     }  
  117.                 }  
  118.                 FileOutputStream fos;  
  119.                 try  
  120.                 {  
  121.                     fos = new FileOutputStream(bitmapFile);  
  122.                     bitmap.compress(Bitmap.CompressFormat.JPEG,   
  123.                             100, fos);  
  124.                     fos.close();  
  125.                 }  
  126.                 catch (FileNotFoundException e)  
  127.                 {  
  128.                     // TODO Auto-generated catch block  
  129.                     e.printStackTrace();  
  130.                 }  
  131.                 catch (IOException e)  
  132.                 {  
  133.                     // TODO Auto-generated catch block  
  134.                     e.printStackTrace();  
  135.                 }  
  136.             }  
  137.         }.start();  
  138.           
  139.         return null;  
  140.     }  
  141.       
  142.     /** 
  143.      * 回调接口 
  144.      * @author onerain 
  145.      * 
  146.      */  
  147.     public interface ImageCallBack  
  148.     {  
  149.         public void imageLoad(ImageView imageView, Bitmap bitmap);  
  150.     }  
  151. }  
  152. </span>  


PS：我这里用到了两个缓冲，一是内存缓存，一个是本地缓存（即SD卡缓存），其中用到了SoftReference，这个类的主要作用是生成一个“软引用”，你可以认为是一种随时会由于JVM垃圾回收机制回收掉的Map对象（而平时我们所用到的引用不释放的话不会被JVM回收），之所以用到软引用，就是考虑到android对图片的缓存是有大小限制的，当超过这个大小时，就一定要释放，如果你用引用，保持不释放的话，那么FC(Force close)就离你不远了。。。我这里还用到了一个本地缓存的机制，是和参考博客不太一样的地方，只是提供一种思路，方法还没有完善（主要因为和服务器还没约定好关于图片的命名规则），主要作用是在用户浏览过大量图片之后（超过内存缓存容量之后），保留在本地，一是为了提高读取速度，二是可以减少流量消耗！


这个类设计好之后，在自定义的Adapter当中比之前会有些不同，先上代码再解释


[java]  view plain copy print ?
  1. <span style="font-size:18px;">package onerain.ald.adapter;  
  2.   
  3. import java.util.List;  
  4.   
  5. import onerain.ald.R;  
  6. import onerain.ald.async.AsyncBitmapLoader;  
  7. import onerain.ald.async.AsyncBitmapLoader.ImageCallBack;  
  8. import onerain.ald.entity.BaseBookEntity;  
  9. import onerain.ald.holder.ViewHolder;  
  10. import android.content.Context;  
  11. import android.graphics.Bitmap;  
  12. import android.view.LayoutInflater;  
  13. import android.view.View;  
  14. import android.view.ViewGroup;  
  15. import android.widget.BaseAdapter;  
  16. import android.widget.ImageView;  
  17. import android.widget.TextView;  
  18.   
  19. /** 
  20.  * @author oneRain 
  21.  **/  
  22. public class ListAdapter extends BaseAdapter  
  23. {  
  24.     private Context context = null;  
  25.     private List<BaseBookEntity> bookList = null;  
  26.       
  27.     private AsyncBitmapLoader asyncLoader = null;  
  28.       
  29.     public ListAdapter(Context context, List<BaseBookEntity> bookList)  
  30.     {  
  31.         this.context = context;  
  32.         this.bookList = bookList;  
  33.         this.asyncLoader = new AsyncBitmapLoader();  
  34.     }  
  35.       
  36.     @Override  
  37.     public int getCount()  
  38.     {  
  39.         // TODO Auto-generated method stub  
  40.         return bookList.size();  
  41.     }  
  42.   
  43.     @Override  
  44.     public Object getItem(int position)  
  45.     {  
  46.         // TODO Auto-generated method stub  
  47.         return bookList.get(position);  
  48.     }  
  49.   
  50.     @Override  
  51.     public long getItemId(int position)  
  52.     {  
  53.         // TODO Auto-generated method stub  
  54.         return position;  
  55.     }  
  56.   
  57.     @Override  
  58.     public View getView(int position, View convertView, ViewGroup parent)  
  59.     {  
  60.         // TODO Auto-generated method stub  
  61.         ViewHolder holder = null;  
  62.           
  63.         if(convertView == null)  
  64.         {  
  65.             LayoutInflater inflater = LayoutInflater.from(context);  
  66.             convertView = inflater.inflate(R.layout.item, null);  
  67.               
  68.             holder = new ViewHolder((ImageView)convertView.findViewById(R.id.imageView),  
  69.                     (TextView)convertView.findViewById(R.id.textView));  
  70.             convertView.setTag(holder);  
  71.         }  
  72.         else  
  73.         {  
  74.             holder = (ViewHolder) convertView.getTag();  
  75.         }  
  76.           
  77.         ImageView imageView = holder.getImageView();  
  78.   
  79.                 <span style="color:#FF0000;">imageView.setImageBitmap(null);</span>  
  80.   
  81.                 //根据图片URL去查找内存缓存有没有对应的Bitmap对象，并传递回调方法，如果没有，则等下载完毕回调  
  82.         Bitmap bitmap = asyncLoader.loadBitmap(imageView,   
  83.                 bookList.get(position).getBook_pic(),  
  84.                 new ImageCallBack()  
  85.                 {  
  86.                     @Override  
  87.                     public void imageLoad(ImageView imageView, Bitmap bitmap)  
  88.                     {  
  89.                         // TODO Auto-generated method stub  
  90.                         imageView.setImageBitmap(bitmap);  
  91.                     }  
  92.                 });  
  93.           
  94.         if(bitmap == null)  
  95.         {  
  96.             imageView.setImageResource(R.drawable.ic_launcher);  
  97.         }  
  98.         else  
  99.         {  
  100.             imageView.setImageBitmap(bitmap);  
  101.         }  
  102.           
  103.         holder.getTextView().setText(bookList.get(position).getTitle());  
  104.           
  105.         return convertView;  
  106.     }  
  107. }  
  108. </span>  


在Adapter中，主要不同表现在

public View getView(int position, View convertView, ViewGroup parent)方法中（我这里用到了一些优化方面的处理，会在其他时间再与大家分享，今天先不解释），和异步加载最相关的是这一段

[java]  view plain copy print ?
  1. <span style="font-size:18px;">ImageView imageView = holder.getImageView();  
  2.         //根据图片URL去查找内存缓存有没有对应的Bitmap对象，并传递回调方法，如果没有，则等下载完毕回调  
  3.     Bitmap bitmap = asyncLoader.loadBitmap(imageView,   
  4.             bookList.get(position).getBook_pic(),  
  5.             new ImageCallBack()  
  6.             {  
  7.                 @Override  
  8.                 public void imageLoad(ImageView imageView, Bitmap bitmap)  
  9.                 {  
  10.                     // TODO Auto-generated method stub  
  11.                     imageView.setImageBitmap(bitmap);  
  12.                 }  
  13.             });  
  14.           
  15.     if(bitmap == null)  
  16.     {  
  17.         imageView.setImageResource(R.drawable.ic_launcher);  
  18.     }  
  19.     else  
  20.     {  
  21.         imageView.setImageBitmap(bitmap);  
  22.     }</span>  

asyncLoader是我们定义的异步加载类的对象，通过这个类的

public Bitmap loadBitmap(final ImageView imageView, final String imageURL, final ImageCallBack imageCallBack)

加载图片，传递参数也与参考博客有些不同，我觉得这样更好理解一下，就是要显示图片的URL链接，和图片要显示对应的控件，当然最重要的还有这个接口实现的回调对象，是在线程中下载完图片之后，用以加载图片的回调对象。而这个回调对象在传递的时候已经实现了接口方法，即将下载好的图片绘制在对应的控件之中


4、Android公共库——图片缓存 网络缓存 下拉及底部更多ListView 公共类


介绍总结的一些android公共库，包含缓存(图片缓存、预取缓存、网络缓存)、公共View(下拉及底部加载更多ListView、底部加载更多ScrollView、滑动一页Gallery)、及Android常用工具类(网络、下载、shell、文件、json等等)。

 

TrineaAndroidCommon已开源，地址为TrineaAndroidCommon@Github，欢迎Star或Fork^_*

示例APK可从这些地址下载：Google Play,  360手机助手,  百度手机助手,  小米应用商店,  豌豆荚

 

PS：这是准备分享的三个系列之一，暂时告一段落，后续准备开始Android性能优化系列以及Java多线程系列。

一. 缓存类

1. 图片缓存
使用见：图片缓存的使用
适用：获取图片较多的应用，如新浪微博、twitter、微信头像、美丽说、蘑菇街、花瓣、淘宝等等。
主要特性：(1). 使用简单  (2). 轻松获取及预取新图片  (3). 包含二级缓存  (4). 可选择多种缓存算法(FIFO、LIFO、LRU、MRU、LFU、MFU等13种)或自定义缓存算法  (5). 可方便的保存及初始化恢复数据  (6).  省流量性能佳(有且仅有一个线程获取图片)  (7). 支持不同类型网络处理  (8). 可根据系统配置初始化缓存  (9). 扩展性强  (10). 支持等待队列  (11). 包含map的大多数接口。
效果图：

image cache demo
2. 图片SD卡缓存
使用见：图片SD卡缓存的使用
适用：应用中获取图片较多且图片较大的情况，在微博、花瓣、美丽说、path这类应用中可以起到很好的效果。
主要特性：(1). 使用简单  (2). 轻松获取及预取新图片  (3). 包含二级缓存  (4). 可选择多种缓存算法(FIFO、LIFO、LRU、MRU、LFU、MFU等13种)或自定义缓存算法  (5). 可方便的保存及初始化恢复数据  (6).  支持文件sd卡保存及自定义文件名规则  (7). 省流量性能佳(有且仅有一个线程获取图片)  (8). 支持不同类型网络处理  (9).  可根据系统配置初始化缓存  (10). 扩展性强  (11). 支持等待队列  (12). 包含map的大多数接口。
效果图：

 

3. 网络缓存

使用见：Android网络缓存

适用：网络获取内容不大的应用，尤其是api接口数据，如新浪微博、twitter的timeline、微信公众账号发送的内容等等。

主要特性：(1). 可同步或异步获取数据  (2). 可自动根据服务器的返回头判断是否需要缓存 (3). 可自动根据请求头信息判断是否读取缓存

效果图：

 

4. 预取数据缓存

使用见：预取数据缓存PreloadDataCache
主要特性：(1).使用简单  (2).可自动预取新数据  (3).可选择多种缓存算法(包括FIFO、LIFO、LRU、MRU、LFU、MFU等15种)或自定义缓存算法  (4).省流量性能佳(有且仅有一个线程获取数据)  (5).支持不同类型网络处理  (6)缓存可序列化到本地  缓存可从文件中恢复  (7).扩展性强  (8). 包含map的大多数接口

 

缓存类关系图如下：其中HttpCache为后续计划的http缓存

 

二. 公用的view
1. 下拉刷新及滚动到底部加载更多的Listview
使用见: 下拉刷新及滚动到底部加载更多listview的使用
主要特性：(1). 可自定义下拉响应事件(如下拉刷新)  (2).可自定义滚动到底部响应的事件(如滑动到底部加载更多)  (3).可自定义丰富的样式  (4).高效(若下拉样式关闭不会加载其布局，同listView效率一致) (5). 丰富的设置

效果图：

dropdown list view demo

 

2. 滑动一页(一个Item)的Gallery
使用及实现原理见：滑动一页(一个Item)的Gallery的使用
效果图：

    

 

3. 滑动到底部或顶部响应的ScrollView
使用及实现原理见: 滚动到底部或顶部响应的ScrollView使用
效果图：

 

三. 工具类

具体介绍可见：Android常用工具类

目前包括HttpUtils、DownloadManagerPro、ShellUtils、PackageUtils、PreferencesUtils、JSONUtils、FileUtils、ResourceUtils、StringUtils、ParcelUtils、RandomUtils、ArrayUtils、ImageUtils、ListUtils、MapUtils、ObjectUtils、SerializeUtils、SystemUtils、TimeUtils。

 

1. Android系统下载管理DownloadManager使用
使用示例见：Android系统下载管理DownloadManager功能介绍及使用示例
功能扩展：Android下载管理DownloadManager功能扩展和bug修改

 

2. Android APK root权限静默安装
使用示例见：Android APK root权限静默安装

 

3. Android root权限

直接调用ShellUtils.execCommand方法

 

4. 图片工具类
(1)Drawable、Bitmap、byte数组相互转换; (2)根据url获得InputStream、Drawable、Bitmap见ImageUtils。

更多工具类介绍见Android常用工具类


原文链接：http://www.trinea.cn/android/android-common-lib/



5、Android之ListView异步加载网络图片(优化缓存机制) .


网上关于这个方面的文章也不少，基本的思路是线程+缓存来解决。下面提出一些优化：

1、采用线程池

2、内存缓存+文件缓存

3、内存缓存中网上很多是采用SoftReference来防止堆溢出，这儿严格限制只能使用最大JVM内存的1/4

4、对下载的图片进行按比例缩放，以减少内存的消耗

具体的代码里面说明。先放上内存缓存类的代码MemoryCache.java：

[java]  view plain copy
  1. public class MemoryCache {  
  2.   
  3.     private static final String TAG = "MemoryCache";  
  4.     // 放入缓存时是个同步操作   
  5.     // LinkedHashMap构造方法的最后一个参数true代表这个map里的元素将按照最近使用次数由少到多排列，即LRU   
  6.     // 这样的好处是如果要将缓存中的元素替换，则先遍历出最近最少使用的元素来替换以提高效率   
  7.     private Map<String, Bitmap> cache = Collections  
  8.             .synchronizedMap(new LinkedHashMap<String, Bitmap>(10, 1.5f, true));  
  9.     // 缓存中图片所占用的字节，初始0，将通过此变量严格控制缓存所占用的堆内存   
  10.     private long size = 0;// current allocated size   
  11.     // 缓存只能占用的最大堆内存   
  12.     private long limit = 1000000;// max memory in bytes   
  13.   
  14.     public MemoryCache() {  
  15.         // use 25% of available heap size   
  16.         setLimit(Runtime.getRuntime().maxMemory() / 4);  
  17.     }  
  18.   
  19.     public void setLimit(long new_limit) {   
  20.         limit = new_limit;  
  21.         Log.i(TAG, "MemoryCache will use up to " + limit / 1024. / 1024. + "MB");  
  22.     }  
  23.   
  24.     public Bitmap get(String id) {  
  25.         try {  
  26.             if (!cache.containsKey(id))  
  27.                 return null;  
  28.             return cache.get(id);  
  29.         } catch (NullPointerException ex) {  
  30.             return null;  
  31.         }  
  32.     }  
  33.   
  34.     public void put(String id, Bitmap bitmap) {  
  35.         try {  
  36.             if (cache.containsKey(id))  
  37.                 size -= getSizeInBytes(cache.get(id));  
  38.             cache.put(id, bitmap);  
  39.             size += getSizeInBytes(bitmap);  
  40.             checkSize();  
  41.         } catch (Throwable th) {  
  42.             th.printStackTrace();  
  43.         }  
  44.     }  
  45.   
  46.     /** 
  47.      * 严格控制堆内存，如果超过将首先替换最近最少使用的那个图片缓存 
  48.      *  
  49.      */  
  50.     private void checkSize() {  
  51.         Log.i(TAG, "cache size=" + size + " length=" + cache.size());  
  52.         if (size > limit) {  
  53.             // 先遍历最近最少使用的元素   
  54.             Iterator<Entry<String, Bitmap>> iter = cache.entrySet().iterator();  
  55.             while (iter.hasNext()) {  
  56.                 Entry<String, Bitmap> entry = iter.next();  
  57.                 size -= getSizeInBytes(entry.getValue());  
  58.                 iter.remove();  
  59.                 if (size <= limit)  
  60.                     break;  
  61.             }  
  62.             Log.i(TAG, "Clean cache. New size " + cache.size());  
  63.         }  
  64.     }  
  65.   
  66.     public void clear() {  
  67.         cache.clear();  
  68.     }  
  69.   
  70.     /** 
  71.      * 图片占用的内存 
  72.      *  
  73.      * @param bitmap 
  74.      * @return 
  75.      */  
  76.     long getSizeInBytes(Bitmap bitmap) {  
  77.         if (bitmap == null)  
  78.             return 0;  
  79.         return bitmap.getRowBytes() * bitmap.getHeight();  
  80.     }  
  81. }  
[java]  view plain copy
  1. public class MemoryCache {  
  2.   
  3.     private static final String TAG = "MemoryCache";  
  4.     // 放入缓存时是个同步操作  
  5.     // LinkedHashMap构造方法的最后一个参数true代表这个map里的元素将按照最近使用次数由少到多排列，即LRU  
  6.     // 这样的好处是如果要将缓存中的元素替换，则先遍历出最近最少使用的元素来替换以提高效率  
  7.     private Map<String, Bitmap> cache = Collections  
  8.             .synchronizedMap(new LinkedHashMap<String, Bitmap>(10, 1.5f, true));  
  9.     // 缓存中图片所占用的字节，初始0，将通过此变量严格控制缓存所占用的堆内存  
  10.     private long size = 0;// current allocated size  
  11.     // 缓存只能占用的最大堆内存  
  12.     private long limit = 1000000;// max memory in bytes  
  13.   
  14.     public MemoryCache() {  
  15.         // use 25% of available heap size  
  16.         setLimit(Runtime.getRuntime().maxMemory() / 4);  
  17.     }  
  18.   
  19.     public void setLimit(long new_limit) {   
  20.         limit = new_limit;  
  21.         Log.i(TAG, "MemoryCache will use up to " + limit / 1024. / 1024. + "MB");  
  22.     }  
  23.   
  24.     public Bitmap get(String id) {  
  25.         try {  
  26.             if (!cache.containsKey(id))  
  27.                 return null;  
  28.             return cache.get(id);  
  29.         } catch (NullPointerException ex) {  
  30.             return null;  
  31.         }  
  32.     }  
  33.   
  34.     public void put(String id, Bitmap bitmap) {  
  35.         try {  
  36.             if (cache.containsKey(id))  
  37.                 size -= getSizeInBytes(cache.get(id));  
  38.             cache.put(id, bitmap);  
  39.             size += getSizeInBytes(bitmap);  
  40.             checkSize();  
  41.         } catch (Throwable th) {  
  42.             th.printStackTrace();  
  43.         }  
  44.     }  
  45.   
  46.     /** 
  47.      * 严格控制堆内存，如果超过将首先替换最近最少使用的那个图片缓存 
  48.      *  
  49.      */  
  50.     private void checkSize() {  
  51.         Log.i(TAG, "cache size=" + size + " length=" + cache.size());  
  52.         if (size > limit) {  
  53.             // 先遍历最近最少使用的元素  
  54.             Iterator<Entry<String, Bitmap>> iter = cache.entrySet().iterator();  
  55.             while (iter.hasNext()) {  
  56.                 Entry<String, Bitmap> entry = iter.next();  
  57.                 size -= getSizeInBytes(entry.getValue());  
  58.                 iter.remove();  
  59.                 if (size <= limit)  
  60.                     break;  
  61.             }  
  62.             Log.i(TAG, "Clean cache. New size " + cache.size());  
  63.         }  
  64.     }  
  65.   
  66.     public void clear() {  
  67.         cache.clear();  
  68.     }  
  69.   
  70.     /** 
  71.      * 图片占用的内存 
  72.      *  
  73.      * @param bitmap 
  74.      * @return 
  75.      */  
  76.     long getSizeInBytes(Bitmap bitmap) {  
  77.         if (bitmap == null)  
  78.             return 0;  
  79.         return bitmap.getRowBytes() * bitmap.getHeight();  
  80.     }  
  81. }  

也可以使用SoftReference，代码会简单很多，但是我推荐上面的方法。

[java]  view plain copy
  1. public class MemoryCache {  
  2.       
  3.     private Map<String, SoftReference<Bitmap>> cache = Collections  
  4.             .synchronizedMap(new HashMap<String, SoftReference<Bitmap>>());  
  5.   
  6.     public Bitmap get(String id) {  
  7.         if (!cache.containsKey(id))  
  8.             return null;  
  9.         SoftReference<Bitmap> ref = cache.get(id);  
  10.         return ref.get();  
  11.     }  
  12.   
  13.     public void put(String id, Bitmap bitmap) {  
  14.         cache.put(id, new SoftReference<Bitmap>(bitmap));  
  15.     }  
  16.   
  17.     public void clear() {  
  18.         cache.clear();  
  19.     }  
  20.   
  21. }  
[java]  view plain copy
  1. public class MemoryCache {  
  2.       
  3.     private Map<String, SoftReference<Bitmap>> cache = Collections  
  4.             .synchronizedMap(new HashMap<String, SoftReference<Bitmap>>());  
  5.   
  6.     public Bitmap get(String id) {  
  7.         if (!cache.containsKey(id))  
  8.             return null;  
  9.         SoftReference<Bitmap> ref = cache.get(id);  
  10.         return ref.get();  
  11.     }  
  12.   
  13.     public void put(String id, Bitmap bitmap) {  
  14.         cache.put(id, new SoftReference<Bitmap>(bitmap));  
  15.     }  
  16.   
  17.     public void clear() {  
  18.         cache.clear();  
  19.     }  
  20.   
  21. }  
下面是文件缓存类的代码FileCache.java:

[java]  view plain copy
  1. public class FileCache {  
  2.   
  3.     private File cacheDir;  
  4.   
  5.     public FileCache(Context context) {  
  6.         // 如果有SD卡则在SD卡中建一个LazyList的目录存放缓存的图片   
  7.         // 没有SD卡就放在系统的缓存目录中   
  8.         if (android.os.Environment.getExternalStorageState().equals(  
  9.                 android.os.Environment.MEDIA_MOUNTED))  
  10.             cacheDir = new File(  
  11.                     android.os.Environment.getExternalStorageDirectory(),  
  12.                     "LazyList");  
  13.         else  
  14.             cacheDir = context.getCacheDir();  
  15.         if (!cacheDir.exists())  
  16.             cacheDir.mkdirs();  
  17.     }  
  18.   
  19.     public File getFile(String url) {  
  20.         // 将url的hashCode作为缓存的文件名   
  21.         String filename = String.valueOf(url.hashCode());  
  22.         // Another possible solution   
  23.         // String filename = URLEncoder.encode(url);   
  24.         File f = new File(cacheDir, filename);  
  25.         return f;  
  26.   
  27.     }  
  28.   
  29.     public void clear() {  
  30.         File[] files = cacheDir.listFiles();  
  31.         if (files == null)  
  32.             return;  
  33.         for (File f : files)  
  34.             f.delete();  
  35.     }  
  36.   
  37. }  
[java]  view plain copy
  1. public class FileCache {  
  2.   
  3.     private File cacheDir;  
  4.   
  5.     public FileCache(Context context) {  
  6.         // 如果有SD卡则在SD卡中建一个LazyList的目录存放缓存的图片  
  7.         // 没有SD卡就放在系统的缓存目录中  
  8.         if (android.os.Environment.getExternalStorageState().equals(  
  9.                 android.os.Environment.MEDIA_MOUNTED))  
  10.             cacheDir = new File(  
  11.                     android.os.Environment.getExternalStorageDirectory(),  
  12.                     "LazyList");  
  13.         else  
  14.             cacheDir = context.getCacheDir();  
  15.         if (!cacheDir.exists())  
  16.             cacheDir.mkdirs();  
  17.     }  
  18.   
  19.     public File getFile(String url) {  
  20.         // 将url的hashCode作为缓存的文件名  
  21.         String filename = String.valueOf(url.hashCode());  
  22.         // Another possible solution  
  23.         // String filename = URLEncoder.encode(url);  
  24.         File f = new File(cacheDir, filename);  
  25.         return f;  
  26.   
  27.     }  
  28.   
  29.     public void clear() {  
  30.         File[] files = cacheDir.listFiles();  
  31.         if (files == null)  
  32.             return;  
  33.         for (File f : files)  
  34.             f.delete();  
  35.     }  
  36.   
  37. }  
最后最重要的加载图片的类，ImageLoader.java:

[java]  view plain copy
  1. public class ImageLoader {  
  2.   
  3.     MemoryCache memoryCache = new MemoryCache();  
  4.     FileCache fileCache;  
  5.     private Map<ImageView, String> imageViews = Collections  
  6.             .synchronizedMap(new WeakHashMap<ImageView, String>());  
  7.     // 线程池   
  8.     ExecutorService executorService;  
  9.   
  10.     public ImageLoader(Context context) {  
  11.         fileCache = new FileCache(context);  
  12.         executorService = Executors.newFixedThreadPool(5);  
  13.     }  
  14.   
  15.     // 当进入listview时默认的图片，可换成你自己的默认图片   
  16.     final int stub_id = R.drawable.stub;  
  17.   
  18.     // 最主要的方法   
  19.     public void DisplayImage(String url, ImageView imageView) {  
  20.         imageViews.put(imageView, url);  
  21.         // 先从内存缓存中查找   
  22.   
  23.         Bitmap bitmap = memoryCache.get(url);  
  24.         if (bitmap != null)  
  25.             imageView.setImageBitmap(bitmap);  
  26.         else {  
  27.             // 若没有的话则开启新线程加载图片   
  28.             queuePhoto(url, imageView);  
  29.             imageView.setImageResource(stub_id);  
  30.         }  
  31.     }  
  32.   
  33.     private void queuePhoto(String url, ImageView imageView) {  
  34.         PhotoToLoad p = new PhotoToLoad(url, imageView);  
  35.         executorService.submit(new PhotosLoader(p));  
  36.     }  
  37.   
  38.     private Bitmap getBitmap(String url) {  
  39.         File f = fileCache.getFile(url);  
  40.   
  41.         // 先从文件缓存中查找是否有   
  42.         Bitmap b = decodeFile(f);  
  43.         if (b != null)  
  44.             return b;  
  45.   
  46.         // 最后从指定的url中下载图片   
  47.         try {  
  48.             Bitmap bitmap = null;  
  49.             URL imageUrl = new URL(url);  
  50.             HttpURLConnection conn = (HttpURLConnection) imageUrl  
  51.                     .openConnection();  
  52.             conn.setConnectTimeout(30000);  
  53.             conn.setReadTimeout(30000);  
  54.             conn.setInstanceFollowRedirects(true);  
  55.             InputStream is = conn.getInputStream();  
  56.             OutputStream os = new FileOutputStream(f);  
  57.             CopyStream(is, os);  
  58.             os.close();  
  59.             bitmap = decodeFile(f);  
  60.             return bitmap;  
  61.         } catch (Exception ex) {  
  62.             ex.printStackTrace();  
  63.             return null;  
  64.         }  
  65.     }  
  66.   
  67.     // decode这个图片并且按比例缩放以减少内存消耗，虚拟机对每张图片的缓存大小也是有限制的   
  68.     private Bitmap decodeFile(File f) {  
  69.         try {  
  70.             // decode image size   
  71.             BitmapFactory.Options o = new BitmapFactory.Options();  
  72.             o.inJustDecodeBounds = true;  
  73.             BitmapFactory.decodeStream(new FileInputStream(f), null, o);  
  74.   
  75.             // Find the correct scale value. It should be the power of 2.   
  76.             final int REQUIRED_SIZE = 70;  
  77.             int width_tmp = o.outWidth, height_tmp = o.outHeight;  
  78.             int scale = 1;  
  79.             while (true) {  
  80.                 if (width_tmp / 2 < REQUIRED_SIZE  
  81.                         || height_tmp / 2 < REQUIRED_SIZE)  
  82.                     break;  
  83.                 width_tmp /= 2;  
  84.                 height_tmp /= 2;  
  85.                 scale *= 2;  
  86.             }  
  87.   
  88.             // decode with inSampleSize   
  89.             BitmapFactory.Options o2 = new BitmapFactory.Options();  
  90.             o2.inSampleSize = scale;  
  91.             return BitmapFactory.decodeStream(new FileInputStream(f), null, o2);  
  92.         } catch (FileNotFoundException e) {  
  93.         }  
  94.         return null;  
  95.     }  
  96.   
  97.     // Task for the queue   
  98.     private class PhotoToLoad {  
  99.         public String url;  
  100.         public ImageView imageView;  
  101.   
  102.         public PhotoToLoad(String u, ImageView i) {  
  103.             url = u;  
  104.             imageView = i;  
  105.         }  
  106.     }  
  107.   
  108.     class PhotosLoader implements Runnable {  
  109.         PhotoToLoad photoToLoad;  
  110.   
  111.         PhotosLoader(PhotoToLoad photoToLoad) {  
  112.             this.photoToLoad = photoToLoad;  
  113.         }  
  114.   
  115.         @Override  
  116.         public void run() {  
  117.             if (imageViewReused(photoToLoad))  
  118.                 return;  
  119.             Bitmap bmp = getBitmap(photoToLoad.url);  
  120.             memoryCache.put(photoToLoad.url, bmp);  
  121.             if (imageViewReused(photoToLoad))  
  122.                 return;  
  123.             BitmapDisplayer bd = new BitmapDisplayer(bmp, photoToLoad);  
  124.             // 更新的操作放在UI线程中   
  125.             Activity a = (Activity) photoToLoad.imageView.getContext();  
  126.             a.runOnUiThread(bd);  
  127.         }  
  128.     }  
  129.   
  130.     /** 
  131.      * 防止图片错位 
  132.      *  
  133.      * @param photoToLoad 
  134.      * @return 
  135.      */  
  136.     boolean imageViewReused(PhotoToLoad photoToLoad) {  
  137.         String tag = imageViews.get(photoToLoad.imageView);  
  138.         if (tag == null || !tag.equals(photoToLoad.url))  
  139.             return true;  
  140.         return false;  
  141.     }  
  142.   
  143.     // 用于在UI线程中更新界面   
  144.     class BitmapDisplayer implements Runnable {  
  145.         Bitmap bitmap;  
  146.         PhotoToLoad photoToLoad;  
  147.   
  148.         public BitmapDisplayer(Bitmap b, PhotoToLoad p) {  
  149.             bitmap = b;  
  150.             photoToLoad = p;  
  151.         }  
  152.   
  153.         public void run() {  
  154.             if (imageViewReused(photoToLoad))  
  155.                 return;  
  156.             if (bitmap != null)  
  157.                 photoToLoad.imageView.setImageBitmap(bitmap);  
  158.             else  
  159.                 photoToLoad.imageView.setImageResource(stub_id);  
  160.         }  
  161.     }  
  162.   
  163.     public void clearCache() {  
  164.         memoryCache.clear();  
  165.         fileCache.clear();  
  166.     }  
  167.   
  168.     public static void CopyStream(InputStream is, OutputStream os) {  
  169.         final int buffer_size = 1024;  
  170.         try {  
  171.             byte[] bytes = new byte[buffer_size];  
  172.             for (;;) {  
  173.                 int count = is.read(bytes, 0, buffer_size);  
  174.                 if (count == -1)  
  175.                     break;  
  176.                 os.write(bytes, 0, count);  
  177.             }  
  178.         } catch (Exception ex) {  
  179.         }  
  180.     }  
  181. }  
[java]  view plain copy
  1. public class ImageLoader {  
  2.   
  3.     MemoryCache memoryCache = new MemoryCache();  
  4.     FileCache fileCache;  
  5.     private Map<ImageView, String> imageViews = Collections  
  6.             .synchronizedMap(new WeakHashMap<ImageView, String>());  
  7.     // 线程池  
  8.     ExecutorService executorService;  
  9.   
  10.     public ImageLoader(Context context) {  
  11.         fileCache = new FileCache(context);  
  12.         executorService = Executors.newFixedThreadPool(5);  
  13.     }  
  14.   
  15.     // 当进入listview时默认的图片，可换成你自己的默认图片  
  16.     final int stub_id = R.drawable.stub;  
  17.   
  18.     // 最主要的方法  
  19.     public void DisplayImage(String url, ImageView imageView) {  
  20.         imageViews.put(imageView, url);  
  21.         // 先从内存缓存中查找  
  22.   
  23.         Bitmap bitmap = memoryCache.get(url);  
  24.         if (bitmap != null)  
  25.             imageView.setImageBitmap(bitmap);  
  26.         else {  
  27.             // 若没有的话则开启新线程加载图片  
  28.             queuePhoto(url, imageView);  
  29.             imageView.setImageResource(stub_id);  
  30.         }  
  31.     }  
  32.   
  33.     private void queuePhoto(String url, ImageView imageView) {  
  34.         PhotoToLoad p = new PhotoToLoad(url, imageView);  
  35.         executorService.submit(new PhotosLoader(p));  
  36.     }  
  37.   
  38.     private Bitmap getBitmap(String url) {  
  39.         File f = fileCache.getFile(url);  
  40.   
  41.         // 先从文件缓存中查找是否有  
  42.         Bitmap b = decodeFile(f);  
  43.         if (b != null)  
  44.             return b;  
  45.   
  46.         // 最后从指定的url中下载图片  
  47.         try {  
  48.             Bitmap bitmap = null;  
  49.             URL imageUrl = new URL(url);  
  50.             HttpURLConnection conn = (HttpURLConnection) imageUrl  
  51.                     .openConnection();  
  52.             conn.setConnectTimeout(30000);  
  53.             conn.setReadTimeout(30000);  
  54.             conn.setInstanceFollowRedirects(true);  
  55.             InputStream is = conn.getInputStream();  
  56.             OutputStream os = new FileOutputStream(f);  
  57.             CopyStream(is, os);  
  58.             os.close();  
  59.             bitmap = decodeFile(f);  
  60.             return bitmap;  
  61.         } catch (Exception ex) {  
  62.             ex.printStackTrace();  
  63.             return null;  
  64.         }  
  65.     }  
  66.   
  67.     // decode这个图片并且按比例缩放以减少内存消耗，虚拟机对每张图片的缓存大小也是有限制的  
  68.     private Bitmap decodeFile(File f) {  
  69.         try {  
  70.             // decode image size  
  71.             BitmapFactory.Options o = new BitmapFactory.Options();  
  72.             o.inJustDecodeBounds = true;  
  73.             BitmapFactory.decodeStream(new FileInputStream(f), null, o);  
  74.   
  75.             // Find the correct scale value. It should be the power of 2.  
  76.             final int REQUIRED_SIZE = 70;  
  77.             int width_tmp = o.outWidth, height_tmp = o.outHeight;  
  78.             int scale = 1;  
  79.             while (true) {  
  80.                 if (width_tmp / 2 < REQUIRED_SIZE  
  81.                         || height_tmp / 2 < REQUIRED_SIZE)  
  82.                     break;  
  83.                 width_tmp /= 2;  
  84.                 height_tmp /= 2;  
  85.                 scale *= 2;  
  86.             }  
  87.   
  88.             // decode with inSampleSize  
  89.             BitmapFactory.Options o2 = new BitmapFactory.Options();  
  90.             o2.inSampleSize = scale;  
  91.             return BitmapFactory.decodeStream(new FileInputStream(f), null, o2);  
  92.         } catch (FileNotFoundException e) {  
  93.         }  
  94.         return null;  
  95.     }  
  96.   
  97.     // Task for the queue  
  98.     private class PhotoToLoad {  
  99.         public String url;  
  100.         public ImageView imageView;  
  101.   
  102.         public PhotoToLoad(String u, ImageView i) {  
  103.             url = u;  
  104.             imageView = i;  
  105.         }  
  106.     }  
  107.   
  108.     class PhotosLoader implements Runnable {  
  109.         PhotoToLoad photoToLoad;  
  110.   
  111.         PhotosLoader(PhotoToLoad photoToLoad) {  
  112.             this.photoToLoad = photoToLoad;  
  113.         }  
  114.   
  115.         @Override  
  116.         public void run() {  
  117.             if (imageViewReused(photoToLoad))  
  118.                 return;  
  119.             Bitmap bmp = getBitmap(photoToLoad.url);  
  120.             memoryCache.put(photoToLoad.url, bmp);  
  121.             if (imageViewReused(photoToLoad))  
  122.                 return;  
  123.             BitmapDisplayer bd = new BitmapDisplayer(bmp, photoToLoad);  
  124.             // 更新的操作放在UI线程中  
  125.             Activity a = (Activity) photoToLoad.imageView.getContext();  
  126.             a.runOnUiThread(bd);  
  127.         }  
  128.     }  
  129.   
  130.     /** 
  131.      * 防止图片错位 
  132.      *  
  133.      * @param photoToLoad 
  134.      * @return 
  135.      */  
  136.     boolean imageViewReused(PhotoToLoad photoToLoad) {  
  137.         String tag = imageViews.get(photoToLoad.imageView);  
  138.         if (tag == null || !tag.equals(photoToLoad.url))  
  139.             return true;  
  140.         return false;  
  141.     }  
  142.   
  143.     // 用于在UI线程中更新界面  
  144.     class BitmapDisplayer implements Runnable {  
  145.         Bitmap bitmap;  
  146.         PhotoToLoad photoToLoad;  
  147.   
  148.         public BitmapDisplayer(Bitmap b, PhotoToLoad p) {  
  149.             bitmap = b;  
  150.             photoToLoad = p;  
  151.         }  
  152.   
  153.         public void run() {  
  154.             if (imageViewReused(photoToLoad))  
  155.                 return;  
  156.             if (bitmap != null)  
  157.                 photoToLoad.imageView.setImageBitmap(bitmap);  
  158.             else  
  159.                 photoToLoad.imageView.setImageResource(stub_id);  
  160.         }  
  161.     }  
  162.   
  163.     public void clearCache() {  
  164.         memoryCache.clear();  
  165.         fileCache.clear();  
  166.     }  
  167.   
  168.     public static void CopyStream(InputStream is, OutputStream os) {  
  169.         final int buffer_size = 1024;  
  170.         try {  
  171.             byte[] bytes = new byte[buffer_size];  
  172.             for (;;) {  
  173.                 int count = is.read(bytes, 0, buffer_size);  
  174.                 if (count == -1)  
  175.                     break;  
  176.                 os.write(bytes, 0, count);  
  177.             }  
  178.         } catch (Exception ex) {  
  179.         }  
  180.     }  
  181. }  
主要流程是先从内存缓存中查找，若没有再开线程，从文件缓存中查找都没有则从指定的url中查找，并对bitmap进行处理，最后通过下面方法对UI进行更新操作。
[java]  view plain copy
  1. a.runOnUiThread(...);  
[java]  view plain copy
  1. a.runOnUiThread(...);  

在你的程序中的基本用法：

[java]  view plain copy
  1. ImageLoader imageLoader=new ImageLoader(context);  
  2. ...  
  3. imageLoader.DisplayImage(url, imageView);  
[java]  view plain copy
  1. ImageLoader imageLoader=new ImageLoader(context);  
  2. ...  
  3. imageLoader.DisplayImage(url, imageView);  
比如你的放在你的ListView的adapter的getView()方法中，当然也适用于GridView。

6、Socket实现文件上传

实现思路：

在客户端获取到文件流，将文件流写入到通过socket指定到某服务器的输出流中，在服务器中通过socket获取到输入流，将数据写入到指定的文件夹内，为了提供多用户同时上传，这里需要将在服务器上传客户端的文件操作放在另开启一个线程去运行。

完整代码:

[java]  view plain copy
  1. import java.net.*;  
  2. import java.io.*;  
  3.   
  4.   
  5. /* 
  6. 服务端将获取到的客户端封装到单独的线程中。 
  7. */  
  8. class  JpgClient2  
  9. {  
  10.     public static void main(String[] args) throws Exception  
  11.     {  
  12.         //检验文件  
  13.         if(args.length==0)  
  14.         {  
  15.             System.out.println("指定一个jpg文件先！");  
  16.             return ;  
  17.         }  
  18.         File file = new File(args[0]);  
  19.         if(!(file.exists() && file.isFile() && file.getName().endsWith(".jpg")))  
  20.         {  
  21.             System.out.println("选择文件错误，请重新选择一个正确的文件。");  
  22.             return ;  
  23.         }  
  24.   
  25.         //读取文件并写入到服务器中  
  26.         Socket s = new Socket("192.168.137.199",9006);  
  27.         FileInputStream fis = new FileInputStream(file);  
  28.         OutputStream out = s.getOutputStream();  
  29.         byte[] buf = new byte[1024];  
  30.         int len = 0;  
  31.         while((len=fis.read(buf))!=-1)  
  32.         {  
  33.             out.write(buf,0,len);  
  34.         }  
  35.           
  36.         //通知服务器发送数据结束  
  37.         s.shutdownOutput();  
  38.   
  39.         //获取服务器响应  
  40.         InputStream in = s.getInputStream();  
  41.         byte[] bufIn = new byte[1024];  
  42.         int num = in.read(bufIn);  
  43.         String str = new String(bufIn,0,num);  
  44.         System.out.println(str);  
  45.   
  46.         fis.close();  
  47.         s.close();  
  48.     }  
  49. }  
  50.   
  51.   
  52. class JpgThread implements Runnable  
  53. {  
  54.     private Socket s;  
  55.     JpgThread(Socket s)  
  56.     {  
  57.         this.s = s;  
  58.     }  
  59.     public void run()  
  60.     {  
  61.         int count = 1;  
  62.   
  63.         String ip = s.getInetAddress().getHostAddress();  
  64.   
  65.         try  
  66.         {  
  67.             //获取客户端数据  
  68.             InputStream in = s.getInputStream();  
  69.               
  70.             //指定文件存放路径将读取到客户提交的数据写入文件中  
  71.             File dir = new File("c:\\pic");  
  72.             File file = new File(dir,ip+"("+count+").jpg");  
  73.             while(file.exists())  
  74.                 file = new File(dir,ip+"("+(count++)+").jpg");  
  75.             FileOutputStream fos = new FileOutputStream(file);  
  76.             byte[] buf = new byte[1024];  
  77.             int len = 0;  
  78.             while((len=in.read(buf))!=-1)  
  79.             {  
  80.                 fos.write(buf,0,len);  
  81.             }  
  82.   
  83.             //返回上传状态给客户端  
  84.             OutputStream out = s.getOutputStream();  
  85.             out.write("上传文件成功".getBytes());  
  86.   
  87.             fos.close();  
  88.             s.close();  
  89.         }  
  90.         catch (Exception e)  
  91.         {  
  92.             System.out.println(e.toString());  
  93.         }  
  94.     }  
  95. }  
  96. class  JpgServer2  
  97. {  
  98.     public static void main(String[] args)throws Exception   
  99.     {  
  100.         ServerSocket ss = new ServerSocket(9006);  
  101.   
  102.         //开启线程并发访问  
  103.         while(true)  
  104.         {  
  105.             Socket s = ss.accept();  
  106.             String ip = s.getInetAddress().getHostAddress();  
  107.             System.out.println(ip+"....connected");  
  108.             new Thread(new JpgThread(s)).start();  
  109.         }  
  110.     }  
  111. }  

小飞鹤
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android开发之ListView 优化之缓存优化
用尽悲伤的专栏
10-25 3017
通过平时对ListView的使用，目前我把ListView的优化分为以下几个方面： 1.缓存优化 2.数据优化 3.其他方面优化 0.未优化简单代码 public class MainActivity extends Activity { private ListView lv_demo; private List list; @Override
Android内存优化总结【整理】
天堂人间
09-10 3万+
【前段时间】 一、Android 内存管理 1.1 Dalvik Dalvik虚拟机是Android程序的虚拟机，是Android中Java程序的运行基础。其指令集基于寄存器架构，执行其特有的文件格式——dex字节码来完成对象生命周期管理、堆栈管理、线程管理、安全异常管理、垃圾回收等重要功能。 Dalvik虚拟机的内存大体上可以分为 Java Object Heap、Bit
android缓存优化技术研究,Android性能优化
weixin_28304023的博客
05-30 104
一、性能相关的两个概念响应时间指从用户操作开始到系统给用户以正确反馈的时间系统处理时间 + 网络传输时间(可能没有) + 展现时间TPS(Transactions Per Second)每秒处理的事务数, 是系统吞吐量的一个指标二、什么是性能问题?响应时间过长, 系统吞吐量过低, 高并发下内存泄漏 (ANR)三、性能调优的方式:降低执行时间缓存(对象缓存,IO缓存, 网络缓存, DB缓存)数据存...
android 增大日志缓存
startupYH的博客
04-28 2376
logcat 1. adb logcat -G 1m 增大到1MBytes 2.Settings -> Developer options -> Logger buffer size设置 dmesg CONFIG_LOG_BUF_SHIFT, 16 -> 2^16 = 64KByte 17 -> 2^17 = 128KByte
Android内存优化之内存缓存
东辉在线的专栏
06-16 3277
前言： 上面两篇博客已经讲了图片的基本知识和图片的加载方法及优化，所有的这些优化都是为了避免应用出现OOM这个问题。一个好的应用程序不仅要健壮不能出错还要方便用户使用，对于用户来说你的应用不仅要美观还要流畅，很快的呈现给他想要的。很快的加载图片除了加载的优化外还需要缓存，下面这篇博客将会讲图片缓存。 什么是缓存？ 缓存技术原理就是把用户访问的所有对象看作一个全集，经过算法标记哪些
Android性能优化-缓存的使用
_StriveG的专栏
03-31 3654
1.前言前面也几篇博客提到了缓存，但是比较零散，最近又对数据缓存有了新的认识，所以来记录下我对缓存的理解，以及我在项目中是如何使用的。2.为什么需要数据缓存以下为我个人看法。 考虑极端环境下的用户体验 断网情况 网速慢的情况 节省客户端流量 减少服务器压力　 3.什么样的数据需要缓存 首先最需要缓存的就是图片了(这个不多说) 其次就是一些非常重要的数据(如app首页数据) 4.常见的数据缓存方法以
Android性能优化：这是一份全面&详细的内存优化指南
热门推荐
Carson带你学Android
03-14 4万+
前言 在 Android开发中，性能优化策略十分重要 本文主要讲解性能优化中的内存优化，希望你们会喜欢 目录 1. 定义 优化处理 应用程序的内存使用、空间占用 2. 作用 避免因不正确使用内存 &amp; 缺乏管理，从而出现 内存泄露（ML）、内存溢出（OOM）、内存空间占用过大 等问题，最终导致应用程序崩溃（Crash） 3. 储备知识：A...
Android实现WebView删除缓存的方法
01-20
在实际开发中，了解和掌握这些清理缓存的方法对优化应用性能、节省用户设备存储空间非常重要。同时，也可以结合其他功能，如动态添加和删除ListView数据、创建和删除桌面快捷方式、实现RecyclerView的多选删除等，来...
Android实现离线缓存的方法
09-02
总之，Android应用可以通过Volley和Universal-ImageLoader实现离线缓存，提升用户体验。但在实际开发中，还需要根据具体需求调整缓存策略，以确保数据的完整性和一致性。同时，了解更多的缓存框架和最佳实践，将有助...
Android使用HBuilder的缓存方法
01-20
总之，掌握有效的本地数据缓存策略对于提升Android应用性能至关重要。通过HBuilder提供的`plus.storage`，开发者可以方便地实现数据的本地存储和读取，同时结合其他缓存策略，构建出高效、流畅的应用体验。
Android基于SoftReference缓存图片的方法
09-01
特别是在处理大量图片时，合理的缓存策略可以避免频繁的IO操作，提高性能。本篇文章将详细探讨如何基于`SoftReference`来缓存图片，以及其原理和实践技巧。 首先，我们需要理解`SoftReference`的概念。在Java中，`...
Android缓存方法
shouchi的博客
04-18 258
一、onSaveInstanceState (Bundle outState)（调用时机onStop之前） 通过重写一个activity的所有生命周期的onXXX方法，包括onSaveInstanceState和onRestoreInstanceState方法，我们可以清楚地知道当某个activity（假定为activity A）显示在当前task的最上层时，其onSaveInstanceStat
Android学习系列(27)--App缓存管理
dianan1505的博客
02-20 356
无论大型或小型应用，灵活的缓存可以说不仅大大减轻了服务器的压力，而且因为更快速的用户体验而方便了用户。Android的apk可以说是作为小型应用，其中99%的应用并不是需要实时更新的，而且诟病于蜗牛般的移动网速，与服务器的数据交互是能少则少，这样用户体验才更好，这也是我们有时舍弃webview而采用json传输数据的原因之一。采用缓存，可以进一步大大缓解数据交互的压力，特此，我们简略列...
Android高效加载Bitmap及缓存机制
沐雨清风
03-16 1086
Android高效加载Bitmap及缓存机制 Android高效加载Bitmap及缓存机制 高效加载Bitmap Bitmap缓存机制 LruCache DiskLruCache 在Android系统中，由于Bitmap的特殊性以及Android对单个应用施加的内存限制等因素，导致加载Bitmap时很容易出现内存溢出问题，即所谓的OOM。那么，如何高效加载Bitmap来降低内存...
Android 清理缓存、优化内存空间
简单玩家丶的博客
08-19 2264
有时候项目中需要清理一些缓存数据（如：图片缓存、网络数据缓存等），当然也要对SharedPreferences存储的数据进行清理，当然App中有个这样的功能可能会提高逼格吧。 public class CacheDataManager { /** * 获取整体缓存大小 * @param context * @return * @throws Ex...
Android Studio logcat 设置 缓存大小 ，增加logcat条数
Yang
11-27 4万+
logcat 经常刷新过快，冲掉之前的数据，可以改下logcat的缓存（缓冲区）大小，可以显示更多行避免被冲掉： 文件： ~/bin/idea.properties 添加一行 idea.cycle.buffer.size=1024000   大小自己控制 如图
Android性能优化之关于缓存的构思
Alex Tam 的专栏
05-18 1710
为了提升用户体验, 对应用显示的数据进行缓存是非常好的方案.用过ListView,GridView,ViewPager等这些组件的童鞋都知道 , 应用都有预加载的行为, 比如当前看的是ViewPager第一页数据, 第二页甚至第三页还没显示出来, 但数据已经准备就绪, 用户只要一滑动到下一页, 数据马上就显示, 而不是等到滑动第二页才去加载(当然有时候为了优化,也可能这么做吧,具体情况具体分析.)
Android性能优化之内存优化（总结篇）
Android技术之家
08-20 7686
前言成为一名优秀的Android开发，需要一份完备的知识体系，在这里，让我们一起成长为自己所想的那样~。内存优化可以说是性能优化中最重要的优化点之一，可以说，如果你没有掌...
Android图片缓存优化和压缩技术说明
zollty的专栏
09-18 352
1、为什么要缓存图片？ 这个机制并非是处理内存占据大小的，而是优化用户体验，节省流量的（去网络获取，这种耗时长且损耗流量）。 PS: 由于我们的图片都是直接读取本地文件，所以，缓存图片意义不是很大。但官方既然这样设计了，估计还是有利于性能提升的。 2、为什么要压缩图片？ Android根据设备屏幕尺寸和dpi的不同，给系统分配的单应用程序内存大小也不同，具体如下表： 屏幕尺寸 DPI 应用内存 small/normal/large ldpi/mdpi 16MB ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值