android-----带你一步一步优化ListView(三)

      前两篇我们介绍了一般的优化ListView方法以及DiskLruCache优化ListView,见android-----带你一步一步优化ListView(一)android-----带你一步一步优化ListView(二),这一篇我们将从内存缓存的角度来完成ListView的优化,使用的是LruCache,它的主要算法原理是把最近使用的对象用强引用存储在 LinkedHashMap 中,并且把最近最少使用的对象在缓存值达到预设定值之前从内存中移除,并没有一个固定的缓存大小是符合所有应用程序的,我们应该根据自己应用程序的状况设置出合理的缓存大小,下面我们通过实例来学习一下LruCache具体怎么使用:

        首先定义显示ListView的布局文件:listview.xml

[java] view plain copy
  1. <?xml version="1.0" encoding="utf-8"?>  
  2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
  3.     android:layout_width="match_parent"  
  4.     android:layout_height="match_parent"  
  5.     android:orientation="vertical" >  
  6.     <ListView   
  7.         android:id="@+id/listView"  
  8.         android:layout_width="match_parent"  
  9.         android:layout_height="match_parent">  
  10.     </ListView>  
  11. </LinearLayout>  
        接着定义每个item显示的样式item.xml

[java] view plain copy
  1. <?xml version="1.0" encoding="utf-8"?>  
  2. <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"  
  3.     android:layout_width="match_parent"  
  4.     android:layout_height="match_parent"  
  5.     android:orientation="vertical" >  
  6.     <ImageView  
  7.         android:id="@+id/imageView"  
  8.         android:layout_width="50dp"  
  9.         android:layout_height="50dp"  
  10.         />  
  11.     <TextView  
  12.         android:id="@+id/textView"  
  13.         android:layout_width="100dp"  
  14.         android:layout_height="50dp"  
  15.         android:layout_toRightOf="@id/imageView"  
  16.         android:layout_marginTop="20dp"  
  17.         android:layout_marginRight="70dp"  
  18.         />  
  19. </RelativeLayout>  
        接下来就是最重要的ListViewAdapter适配器内容了,代码有点长度,先贴出来,接下来慢慢解释:

[java] view plain copy
  1. public class ListViewAdapter extends BaseAdapter{  
  2.   
  3.     //存储所有将要访问的路径  
  4.     public List<String> list;  
  5.     public LruCache<String, Bitmap> lruCache;  
  6.     public LayoutInflater inflater;  
  7.     public ListView listView;  
  8.     public int reqWidth;  
  9.     public int reqHeight;  
  10.     public Set<ImageAsyncTask> tasks = new HashSet<ListViewAdapter.ImageAsyncTask>();  
  11.   
  12.       
  13.     public ListViewAdapter(Context context,List<String> list,LruCache<String, Bitmap> lruCache,ListView listView,ImageView imageView)  
  14.     {  
  15.         this.list = list;  
  16.         this.lruCache = lruCache;  
  17.         this.inflater = LayoutInflater.from(context);  
  18.         this.listView = listView;  
  19.         LayoutParams params = imageView.getLayoutParams();  
  20.         reqWidth = params.width;  
  21.         reqHeight = params.height;  
  22.     }  
  23.     @Override  
  24.     public int getCount() {  
  25.         return list.size();  
  26.     }  
  27.   
  28.     @Override  
  29.     public String getItem(int position) {  
  30.         return list.get(position);  
  31.     }  
  32.   
  33.     @Override  
  34.     public long getItemId(int position) {  
  35.         return position;  
  36.     }  
  37.   
  38.     @Override  
  39.     public View getView(int position, View convertView, ViewGroup parent) {  
  40.         View view = null;  
  41.         ViewHolder holder = null;  
  42.         if(convertView == null)  
  43.         {  
  44.             view = inflater.inflate(R.layout.item, null);  
  45.             holder = new ViewHolder();  
  46.             holder.imageView = (ImageView) view.findViewById(R.id.imageView);  
  47.             holder.textView = (TextView) view.findViewById(R.id.textView);  
  48.             view.setTag(holder);  
  49.         }else  
  50.         {  
  51.             view = convertView;  
  52.             holder = (ViewHolder) view.getTag();  
  53.         }  
  54.         //为ImageView以及TextView设置Tag防止出现乱序  
  55.         holder.imageView.setTag(position);  
  56.         holder.textView.setTag(position+"#");  
  57.         return view;  
  58.     }  
  59.       
  60.     /** 
  61.      * 添加当前key值对应的Bitmap到LruCache中 
  62.      * @param key 
  63.      * @param bitmap 
  64.      */  
  65.     public void addBitmapToMemoryCache(String key,Bitmap bitmap)  
  66.     {  
  67.         if(getBitmapFromMemoryCache(key) == null)  
  68.         {  
  69.             lruCache.put(key, bitmap);  
  70.         }  
  71.     }  
  72.       
  73.     /** 
  74.      * 从LruCache中获取对应于key的Bitmap对象 
  75.      * @param key 
  76.      * @return 
  77.      */  
  78.     public Bitmap getBitmapFromMemoryCache(String key)  
  79.     {  
  80.         return lruCache.get(key);  
  81.     }  
  82.       
  83.     /** 
  84.      * 加载某一位置上的图片 
  85.      * @param url 
  86.      * @param position 
  87.      */  
  88.     public void loadImage(int position)  
  89.     {  
  90.         //获取到position位置对应的url  
  91.         String url = getItem(position);  
  92.         Bitmap bitmap = null;  
  93.         bitmap = getBitmapFromMemoryCache(url);  
  94.         if(bitmap != null)  
  95.         {  
  96.             //表示缓存中存在对应的于此url的Bitmap,则直接获得该Bitmap并且显示到ListView上面  
  97.             ImageView imageView = (ImageView) listView.findViewWithTag(position);  
  98.             TextView textView = (TextView) listView.findViewWithTag(position+"#");  
  99.             if(imageView != null)  
  100.                 imageView.setImageBitmap(bitmap);  
  101.             if(textView != null)  
  102.                 textView.setText("从缓存中获取的");  
  103.         }else  
  104.         {  
  105.             //开启线程从网络中加载图片  
  106.             ImageAsyncTask task = new ImageAsyncTask(listView, position);  
  107.             task.setOnImageLoadListener(new OnImageLoadListener() {  
  108.                   
  109.                 @Override  
  110.                 public void onSuccessLoad(Bitmap bitmap) {  
  111.                     System.out.println("加载图片成功");  
  112.                 }  
  113.                   
  114.                 @Override  
  115.                 public void onFailureLoad() {  
  116.                     System.out.println("加载图片失败");  
  117.                 }  
  118.             });  
  119.             tasks.add(task);  
  120.             task.execute(url);//开启线程加载图片  
  121.         }  
  122.     }  
  123.       
  124.     /** 
  125.      * 暂停所有任务(为了防止在滑动的时候仍然有线程处于请求状态) 
  126.      */  
  127.     public void cancelTask()  
  128.     {  
  129.         if(tasks != null)  
  130.         {  
  131.             for(ImageAsyncTask task: tasks)  
  132.                 task.cancel(false);//暂停任务  
  133.         }  
  134.     }  
  135.       
  136.     /** 
  137.      * 对图片进行压缩处理 
  138.      * @param in 
  139.      * @param reqWidth 
  140.      * @param reqHeight 
  141.      * @return 
  142.      */  
  143.     public static Bitmap decodeSampleBitmapFromStream(InputStream in,int reqWidth,int reqHeight)  
  144.     {  
  145.         //设置BitmapFactory.Options的inJustDecodeBounds属性为true表示禁止为bitmap分配内存  
  146.         BitmapFactory.Options options = new BitmapFactory.Options();  
  147.         options.inJustDecodeBounds = true;  
  148.         byte[] data = inputStreamToByteArray(in);  
  149.         //这次调用的目的是获取到原始图片的宽、高,但是这次操作是没有写内存操作的  
  150.         Bitmap beforeBitmap = BitmapFactory.decodeByteArray(data, 0, data.length, options);  
  151.         options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);  
  152.         //设置这次加载图片需要加载到内存中  
  153.         options.inJustDecodeBounds = false;  
  154.         Bitmap afterBitmap = BitmapFactory.decodeByteArray(data, 0, data.length, options);  
  155.         return afterBitmap;  
  156.     }  
  157.       
  158.     /** 
  159.      * 计算出压缩比 
  160.      * @param options 
  161.      * @param reqWith 
  162.      * @param reqHeight 
  163.      * @return 
  164.      */  
  165.     public static int calculateInSampleSize(BitmapFactory.Options options,int reqWidth,int reqHeight)  
  166.     {  
  167.         //通过参数options来获取真实图片的宽、高  
  168.         int width = options.outWidth;  
  169.         int height = options.outHeight;  
  170.         int inSampleSize = 1;//初始值是没有压缩的  
  171.         if(width > reqWidth || height > reqHeight)  
  172.         {  
  173.             //计算出原始宽与现有宽,原始高与现有高的比率  
  174.             int widthRatio = Math.round((float)width/(float)reqWidth);  
  175.             int heightRatio = Math.round((float)height/(float)reqHeight);  
  176.             //选出两个比率中的较小值,这样的话能够保证图片显示完全   
  177.             inSampleSize = widthRatio < heightRatio ? widthRatio:heightRatio;  
  178.         }  
  179.         return inSampleSize;  
  180.     }  
  181.       
  182.     /** 
  183.      * 将InputStream转换为Byte数组 
  184.      * @param in 
  185.      * @return 
  186.      */  
  187.     public static byte[] inputStreamToByteArray(InputStream in)  
  188.     {  
  189.         ByteArrayOutputStream outputStream = new ByteArrayOutputStream();  
  190.         byte[] buffer = new byte[1024];  
  191.         int len;  
  192.         try {  
  193.             while((len = in.read(buffer)) != -1)  
  194.             {  
  195.                 outputStream.write(buffer, 0, len);  
  196.             }  
  197.         } catch (IOException e) {  
  198.             e.printStackTrace();  
  199.         }finally{  
  200.             try {  
  201.                 in.close();  
  202.                 outputStream.close();  
  203.             } catch (IOException e) {  
  204.                 e.printStackTrace();  
  205.             }  
  206.         }  
  207.         return outputStream.toByteArray();  
  208.     }  
  209.     static class ViewHolder  
  210.     {  
  211.         ImageView imageView;  
  212.         TextView textView;  
  213.     }  
  214.       
  215.     class ImageAsyncTask extends AsyncTask<String, Void, Bitmap>  
  216.     {  
  217.         public ListView listView;  
  218.         public OnImageLoadListener listener;  
  219.         public int position;  
  220.           
  221.         public ImageAsyncTask(ListView listView,int position)  
  222.         {  
  223.             this.listView = listView;  
  224.             this.position = position;  
  225.         }  
  226.           
  227.         public void setOnImageLoadListener(OnImageLoadListener listener)  
  228.         {  
  229.             this.listener = listener;  
  230.         }  
  231.         @Override  
  232.         protected Bitmap doInBackground(String... params) {  
  233.             String urlString = params[0];  
  234.             URL url = null;  
  235.             InputStream in = null;  
  236.             HttpURLConnection connection = null;  
  237.             Bitmap bitmap = null;  
  238.             try {  
  239.                 url = new URL(urlString);  
  240.                 connection = (HttpURLConnection) url.openConnection();  
  241.                 in = connection.getInputStream();  
  242.                 bitmap = decodeSampleBitmapFromStream(in, reqWidth, reqHeight);  
  243.                 //将当前Bitmap添加到缓存中  
  244.                 if(bitmap != null)  
  245.                     lruCache.put(urlString, bitmap);  
  246.             } catch (Exception e) {  
  247.                 e.printStackTrace();  
  248.             }  
  249.             return bitmap;  
  250.         }  
  251.           
  252.         @Override  
  253.         protected void onPostExecute(Bitmap result) {  
  254.             if(result != null)  
  255.             {  
  256.                 listener.onSuccessLoad(result);  
  257.                 ImageView imageView = (ImageView) listView.findViewWithTag(position);  
  258.                 TextView textView = (TextView)listView.findViewWithTag(position+"#");  
  259.                 if(imageView != null)  
  260.                     imageView.setImageBitmap(result);  
  261.                 if(textView != null)  
  262.                     textView.setText("从网络中获取的");  
  263.             }else  
  264.                 listener.onFailureLoad();  
  265.         }  
  266.     }  
  267. }  

        其中39行的getView方法代码就是我们平常使用ListView的常规写法,复用convertView以及对每个view设置viewHolder,为防止图片加载出现乱序,第55、56行我们分别对ImageView以及TextView设置了Tag标志;

        第65行的addBitmapToMemoryCache用于向LruCache中添加当前Bitmap位图,因为LruCache本身实际上是由LinkedHashMap实现的,所有调用的是put方法;

        第78行的getBitmapFromMemoryCache方法用于从LruCache缓存中读取指定key值的Bitmap位图;

        第88行的loadImage就是我们的核心代码,首先第91行会通过调用getItem方法来获得当前item条目所要加载图片的url,随后93行调用getBitmapFromMemoryCache查看缓存中是否存在指定key值的Bitmap,第94行进行判断,如果存在Bitmap的话,则进入if语句块中,97、98行通过findViewWithTag来获得对应条目的ImageView以及TextView,并且将当前获取到的缓存图片显示到当前item;如果当前缓存中不存在的话,则进入103行的else语句块中,106行定义一个ImageAsyncTask图片加载线程,并在119行将当前线程加入到Set<ImageAsyncTask>类型的tasks集合中,便于我们随后对加载图片线程进行控制,第120行调用execute方法,将当前需要加载图片的url传入;

       execute接下会调用ImageAsyncTask的doInBackground方法来加载图片,这里的图片加载方法和之前android-----带你一步一步优化ListView(二) 是一致的,不清楚的朋友可以看看上一篇博客,另外这里面也用到了图片压缩技术,不太懂的可以看看android-----解决Bitmap内存溢出的一种方法(图片压缩技术),在图片压缩完成之后会在第245行将当前Bitmap添加到LruCache中,随后在onPostExecute中进行更新UI的操作即可啦;

最后就是MainActivity方法了:

[java] view plain copy
  1. public class MainActivity extends Activity implements OnScrollListener {  
  2.   
  3.     public LruCache<String, Bitmap> memoryCache;  
  4.     public int start_index;  
  5.     public int end_index;  
  6.     public ListViewAdapter adapter;  
  7.     public boolean isInit = true;  
  8.     public String[] images =  { "http://img.my.csdn.net/uploads/201407/26/1406383299_1976.jpg",    
  9.                                 "http://img.my.csdn.net/uploads/201407/26/1406383291_6518.jpg",    
  10.                                 "http://img.my.csdn.net/uploads/201407/26/1406383291_8239.jpg",    
  11.                                 "http://img.my.csdn.net/uploads/201407/26/1406383290_9329.jpg",    
  12.                                 "http://img.my.csdn.net/uploads/201407/26/1406383290_1042.jpg",    
  13.                                 "http://img.my.csdn.net/uploads/201407/26/1406383275_3977.jpg",    
  14.                                 "http://img.my.csdn.net/uploads/201407/26/1406383265_8550.jpg",    
  15.                                 "http://img.my.csdn.net/uploads/201407/26/1406383264_3954.jpg",    
  16.                                 "http://img.my.csdn.net/uploads/201407/26/1406383264_4787.jpg",    
  17.                                 "http://img.my.csdn.net/uploads/201407/26/1406383264_8243.jpg",    
  18.                                 "http://img.my.csdn.net/uploads/201407/26/1406383248_3693.jpg",    
  19.                                 "http://img.my.csdn.net/uploads/201407/26/1406383243_5120.jpg",    
  20.                                 "http://img.my.csdn.net/uploads/201407/26/1406383242_3127.jpg",    
  21.                                 "http://img.my.csdn.net/uploads/201407/26/1406383242_9576.jpg",    
  22.                                 "http://img.my.csdn.net/uploads/201407/26/1406383242_1721.jpg",    
  23.                                 "http://img.my.csdn.net/uploads/201407/26/1406383219_5806.jpg",    
  24.                                 "http://img.my.csdn.net/uploads/201407/26/1406383214_7794.jpg",    
  25.                                 "http://img.my.csdn.net/uploads/201407/26/1406383213_4418.jpg",    
  26.                                 "http://img.my.csdn.net/uploads/201407/26/1406383213_3557.jpg",    
  27.                                 "http://img.my.csdn.net/uploads/201407/26/1406383210_8779.jpg"};  
  28.     public List<String> list = new ArrayList<String>();  
  29.     public ListView listView;  
  30.     public ImageView imageView;  
  31.       
  32.     @Override  
  33.     protected void onCreate(Bundle savedInstanceState) {  
  34.         super.onCreate(savedInstanceState);  
  35.         setContentView(R.layout.listview);  
  36.         memoryCache = getLruCache();  
  37.         for(int i = 0;i < 50;i++)  
  38.         {  
  39.             int index = i %(images.length);  
  40.             list.add(images[index]);  
  41.         }  
  42.         listView = (ListView) findViewById(R.id.listView);  
  43.         LayoutInflater inflater = LayoutInflater.from(this);  
  44.         View view = inflater.inflate(R.layout.item, null);  
  45.         imageView = (ImageView) view.findViewById(R.id.imageView);  
  46.         adapter = new ListViewAdapter(this, list, memoryCache, listView, imageView);  
  47.         listView.setOnScrollListener(this);  
  48.         listView.setAdapter(adapter);  
  49.     }  
  50.       
  51.     /** 
  52.      * 获得LruCache对象 
  53.      * @return 
  54.      */  
  55.     public LruCache<String, Bitmap> getLruCache()  
  56.     {  
  57.         LruCache<String, Bitmap> cache = null;  
  58.         //获得可用的内存大小  
  59.         int maxMemory = (int)(Runtime.getRuntime().maxMemory()/1024);  
  60.         //将其1/8设置成我们的内存缓存大小  
  61.         int cacheSize = maxMemory/8;  
  62.         cache = new LruCache<String, Bitmap>(cacheSize){  
  63.             @Override  
  64.             protected int sizeOf(String key, Bitmap value) {  
  65.                 //返回当前图片的大小(getByteCount用于返回当前位图所占用的内存字节数)  
  66.                 return value.getByteCount() / 1024;  
  67.             }  
  68.         };  
  69.         return cache;  
  70.     }  
  71.   
  72.     @Override  
  73.     public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) {  
  74.         start_index = firstVisibleItem;  
  75.         end_index = start_index + visibleItemCount;  
  76.         if(isInit == true && visibleItemCount > 0)  
  77.         {  
  78.             for(int i = start_index;i < end_index;i++)  
  79.             {  
  80.                 adapter.loadImage(i);  
  81.             }  
  82.             isInit = false;  
  83.         }  
  84.     }  
  85.     @Override  
  86.     public void onScrollStateChanged(AbsListView view, int scrollState) {  
  87.         if(scrollState == AbsListView.OnScrollListener.SCROLL_STATE_IDLE)  
  88.         {  
  89.             //表示停止滑动,这时候就可以加载图片  
  90.             for(int i = start_index;i < end_index;i++)  
  91.             {  
  92.                 adapter.loadImage(i);  
  93.             }  
  94.         }else  
  95.         {  
  96.             adapter.cancelTask();  
  97.         }  
  98.     }  
  99. }  

        这里比较关键的代码就是第55行的getLruCache方法了,首先会通过Runtime.getRuntime().maxMemory()获得当前可用的内存大小,之后的cacheSize就是我们自己设置的LruCache所用的内存大小,第66行的sizeof方法用于返回当前图片的大小;

        同样,类似于上一篇中DiskLruCache的使用,这里我们也设置了ListView的滑动事件,保证其在滑动的过程中不会进行加载图片的请求操作,滑动停止再去加载图片;

        另外提示一句,不要忘记添加访问网络的权限:

[java] view plain copy
  1. <uses-permission android:name="android.permission.INTERNET"></uses-permission>  
点击下载源码!!!!!

我把上一篇博客和这篇的代码整合成了一个完整的带有DiskLruCache和LruCache缓存的ListView版本:

点击下载整合源码!!!!!

阅读更多
个人分类: listView
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭
关闭