1，listview加载性能优化ViewHolder

转自： http://blog.csdn.net/jacman/article/details/7087995

在android开发中Listview是一个很重要的组件，它以列表的形式根据数据的长自适应展示具体内容,用户可以*的定义listview每一列的布局，但当listview有大量的数据需要加载的时候，会占据大量内存，影响性能，这时候就需要按需填充并重新使用view来减少对象的创建。

ListView加载数据都是在public View getView(int position, View convertView, ViewGroup parent) {}方法中进行的(要自定义listview都需要重写listadapter:如BaseAdapter，SimpleAdapter,CursorAdapter的等的getvView方法),优化listview的加载速度就要让convertView匹配列表类型，并最大程度上的重新使用convertView。

getview的加载方法一般有以下三种种方式：

最慢的加载方式是每一次都重新定义一个View载入布局，再加载数据

public View getView(int position, View convertView, ViewGroup parent) {

View item = mInflater.inflate(R.layout.list_item_icon_text, null);

((TextView) item.findViewById(R.id.text)).setText(DATA[position]);

((ImageView) item.findViewById(R.id.icon)).setImageBitmap(

(position & 1) == 1 ? mIcon1 : mIcon2);

return item;

}

正确的加载方式是当convertView不为空的时候直接重新使用convertView从而减少了很多不必要的View的创建，然后加载数据

public View getView(int position, View convertView, ViewGroup parent) {

if (convertView == null) {

convertView = mInflater.inflate(R.layout.item, parent, false);

}

((TextView) convertView.findViewById(R.id.text)).setText(DATA[position]);

((ImageView) convertView.findViewById(R.id.icon)).setImageBitmap(

(position & 1) == 1 ? mIcon1 : mIcon2);

return convertView;

}

最快的方式是定义一个ViewHolder，将convetView的tag设置为ViewHolder,不为空时重新使用即可

static class ViewHolder {

TextView text;

ImageView icon;

}

public View getView(int position, View convertView, ViewGroup parent) {

ViewHolder holder;

if (convertView == null) {

convertView = mInflater.inflate(R.layout.list_item_icon_text,

parent, false);

holder = new ViewHolder();

holder.text = (TextView) convertView.findViewById(R.id.text);

holder.icon = (ImageView) convertView.findViewById(R.id.icon);

convertView.setTag(holder);

} else {

holder = (ViewHolder) convertView.getTag();

}

holder.text.setText(DATA[position]);

holder.icon.setImageBitmap((position & 1) == 1 ? mIcon1 : mIcon2);

return convertView;

}

三种方式加载效率对比如下图所示：

说明：上述三个例子代码摘自google 2010 I/O大会

当处理一些耗时的资源加载的时候需要做到以下几点，以使你的加载更快更平滑：

1.   适配器在界面主线程中进行修改

2.   可以在任何地方获取数据但应该在另外一个地方请求数据

3.   在主界面的线程中提交适配器的变化并调用notifyDataSetChanged()方法

2，利用convertView优化ListView性能

转自： http://blog.csdn.net/cc_lq/article/details/7090142

转自： http://www.jb51.net/article/31886.htm

这篇文章只是总结下getView里面优化视图的几种写法，就像孔乙己写茴香豆的茴字的几种写法一样，高手勿喷，勿笑，只是拿出来分享，有错误的地方欢迎大家指正，谢谢。 
listview 
Aviewthatshowsitemsinaverticallyscrollinglist。 
一个显示一个垂直的滚动子项的列表视图在android开发中，使用listview的地方很多，用它来展现数据，成一个垂直的视图。使用listview是一个标准的适配器模式，用数据--，界面--xml以及适配器--adapter，数据被适配器按照需要的方式展现出来，xml描写了数据如何展现，activity中控制这些活动。 
其中使用自定义的adapter，会要重写getView方法，在getView方法产生给用户item的视图以及数据。 
见图： 
 
这里有一个优化的地方，就是重用view，这样减少内存消耗，同时加快item加载速度。 
在getView中优化的地方，大家想必都非常情况，下面我总结了三种优化的写法，请大家指正。 
第一： 
重用了convertView，很大程度上的减少了内存的消耗。通过判断convertView是否为null，是的话就需要产生一个视图出来，然后给这个视图数据，最后将这个视图返回给底层，呈献给用户。 
特点：如果当前的convertView为null，则通过LayoutInflat产生一个view。

第二： 
上面的写法会有一个缺点，就是每次在getVIew的时候，都需要重新的findViewById，重新找到控件，然后进行控件的赋值以及事件相应设置。这样其实在做重复的事情，因为的geiview中，其实包含有这些控件，而且这些控件的id还都是一样的，也就是其实只要在view中findViewById一次，后面无需要每次都要findViewById了。 
下面给出第二种写法 
写发的特点，通常有一个内部类classViewHolder,这个ViewHolder,用来标识view中一些控件，方便进行一些事件相应操作的设置，比如onClick等等，这样可以不用每次都要findViewById了，减少了性能的消耗。同时重用了convertView，很大程度上的减少了内存的消耗。

第三： 
　个人觉得这个写法是最舒服的，最舒服的意思是看着代码有一种很爽，看的很清晰。 
特点，使用了内部类classViewHolder、重用了convertView。 
区别第二种写法是，使用了一个临时变量Viewview=convertView，然后修改view，最后返回view

以上就是集中写法，供新手学习和总结。 
源代码如下：LisViewTest.zip 
根据楼下朋友提供的建议，发现还有优化的地方，最新更新如下：

注意：staticclassViewHolder 
这里设置ViewHolder为static，也就是静态的，静态类只会在第一次加载时会耗费比较长时间，但是后面就可以很好帮助加载，同时保证了内存中只有一个ViewHolder，节省了内存的开销。 
非常感谢大家提出建议以及大家的关注！

4，[Android]ListView性能优化之视图缓存

http://www.cnblogs.com/over140/archive/2011/03/23/1991100.html

　　一、准备

　　　　1.1　　了解关于Google IO大会关于Adapter的优化，参考以下文章：

　　　　　　Android开发之ListView 适配器（Adapter）优化

　　　　　　Android开发——09Google I/O之让Android UI性能更高效(1)

　　　　　　PDF下载：Google IO.pdf

　　　　1.2　　准备测试代码：

　　　　　　Activity

    private TestAdapter mAdapter;

    private String[] mArrData;
    private TextView mTV;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        mTV = (TextView) findViewById(R.id.tvShow);

        mArrData = new String[1000];
        for (int i = 0; i < 1000; i++) {
            mArrData[i] = "Google IO Adapter" + i;
        }
        mAdapter = new TestAdapter(this, mArrData);
        ((ListView) findViewById(android.R.id.list)).setAdapter(mAdapter);
    }

　　　　　　代码说明：模拟一千条数据，TestAdapter继承自BaseAdapter，main.xml见文章末尾下载。

　　二、测试

　　　　测试方法：手动滑动ListView至position至50然后往回滑动，充分利用convertView不等于null的代码段。

　　　　2.1　　方案一

　　　　　　按照Google I/O介绍的第二种方案，把item子元素分别改为4个和10个，这样效果更佳明显。

　　　　　　2.1.1　　测试代码

        private int count = 0;
        private long sum = 0L;
        @Override
        public View getView(int position, View convertView, ViewGroup parent) {
            //开始计时
            long startTime = System.nanoTime();
            
            if (convertView == null) {
                convertView = mInflater.inflate(R.layout.list_item_icon_text,
                        null);
            }
            ((ImageView) convertView.findViewById(R.id.icon1)).setImageResource(R.drawable.icon);
            ((TextView) convertView.findViewById(R.id.text1)).setText(mData[position]);
            ((ImageView) convertView.findViewById(R.id.icon2)).setImageResource(R.drawable.icon);
            ((TextView) convertView.findViewById(R.id.text2)).setText(mData[position]);
            
            //停止计时
            long endTime = System.nanoTime();
            //计算耗时
            long val = (endTime - startTime) / 1000L;
            Log.e("Test", "Position:" + position + ":" + val);
            if (count < 100) {
                if (val < 1000L) {
                    sum += val;
                    count++;
                }
            } else
                mTV.setText(String.valueOf(sum / 100L));//显示统计结果
            return convertView;
        }

　　　　　　2.1.2　　测试结果（微秒除以1000，见代码）

        private int count = 0;
        private long sum = 0L;

        @Override
        public View getView(int position, View convertView, ViewGroup parent) {
            // 开始计时
            long startTime = System.nanoTime();

            ViewHolder holder;
            if (convertView == null) {
                convertView = mInflater.inflate(R.layout.list_item_icon_text,
                        null);
                holder = new ViewHolder();
                holder.icon1 = (ImageView) convertView.findViewById(R.id.icon1);
                holder.text1 = (TextView) convertView.findViewById(R.id.text1);
                holder.icon2 = (ImageView) convertView.findViewById(R.id.icon2);
                holder.text2 = (TextView) convertView.findViewById(R.id.text2);
                convertView.setTag(holder);
            }
            else{
                holder = (ViewHolder)convertView.getTag();
            }
            holder.icon1.setImageResource(R.drawable.icon);
            holder.text1.setText(mData[position]);
            holder.icon2 .setImageResource(R.drawable.icon);
            holder.text2.setText(mData[position]);

            // 停止计时
            long endTime = System.nanoTime();
            // 计算耗时
            long val = (endTime - startTime) / 1000L;
            Log.e("Test", "Position:" + position + ":" + val);
            if (count < 100) {
                if (val < 1000L) {
                    sum += val;
                    count++;
                }
            } else
                mTV.setText(String.valueOf(sum / 100L));// 显示统计结果
            return convertView;
        }
    }

    static class ViewHolder {
        TextView text1;
        ImageView icon1;
        TextView text2;
        ImageView icon2;
    }

        @Override
        public View getView(int position, View convertView, ViewGroup parent) {
            // 开始计时
            long startTime = System.nanoTime();

            if (convertView == null) {
                convertView = mInflater.inflate(R.layout.list_item_icon_text, null);
                convertView.setTag(R.id.icon1, convertView.findViewById(R.id.icon1));
                convertView.setTag(R.id.text1, convertView.findViewById(R.id.text1));
                convertView.setTag(R.id.icon2, convertView.findViewById(R.id.icon2));
                convertView.setTag(R.id.text2, convertView.findViewById(R.id.text2));
            }
            ((ImageView) convertView.getTag(R.id.icon1)).setImageResource(R.drawable.icon);
            ((ImageView) convertView.getTag(R.id.icon2)).setImageResource(R.drawable.icon);
            ((TextView) convertView.getTag(R.id.text1)).setText(mData[position]);
            ((TextView) convertView.getTag(R.id.text2)).setText(mData[position]);

            // 停止计时
            long endTime = System.nanoTime();
            // 计算耗时
            long val = (endTime - startTime) / 1000L;
            Log.e("Test", "Position:" + position + ":" + val);
            if (count < 100) {
                if (val < 1000L) {
                    sum += val;
                    count++;
                }
            } else
                mTV.setText(String.valueOf(sum / 100L) + ":" + nullcount);// 显示统计结果
            return convertView;
        }

　　　　4.1　　首先有一个认识是错误的，我们先来看截图：

　　　　　　可以发现，只有第一屏（可视范围）调用getView所消耗的时间远远多于后面的，通过对

            if (convertView == null) {
                convertView = mInflater.inflate(R.layout.list_item_icon_text, null);
                ((ImageView) convertView.findViewById(R.id.icon1)).setImageResource(R.drawable.icon);
                ((TextView) convertView.findViewById(R.id.text1)).setText(mData[position]);
                ((ImageView) convertView.findViewById(R.id.icon2)).setImageResource(R.drawable.icon);
                ((TextView) convertView.findViewById(R.id.text2)).setText(mData[position]);
            }
            else
                return convertView;

　　　　4.2　　本文方案一与方案二对比

　　　　　　这里推荐如果只是一般的应用（一般指子控件不多），无需都是用静态内部类来优化，使用第二种方案即可；反之，对性能要求较高时可采用。此外需要提醒的是这里也是用空间换时间的做法，View本身因为setTag而会占用更多的内存，还会增加代码量；而findViewById会临时消耗更多的内存，所以不可盲目使用，依实际情况而定。

　　　　4.3　　方案三

　　　　　　此方案为“Henry Hu”提示，API Level 4以上支持，原理和方案三一致，减少findViewById次数，但是从测试结果来看效果并不理想，这里不再做进一步的测试。

　　五、推荐文章

　　　　Android，谁动了我的内存(1)

　　　　Android 内存泄漏调试

2011-3-30  参见这里(http://www.javaeye.com/topic/971782)的讨论，据此将计划写续篇。

结束

　　对于Google I/O大会这个优化方案一直抱迟疑态度，此番测试总算是有了更进一步的了解，欢迎大家先测试后交流，看看还有什么办法能够再优化一点。

5，Android开发——09Google I/O之让Android UI性能更高效(1)

http://www.cnblogs.com/halzhang/archive/2010/12/05/1896791.html

一、前言

前几天发现09年Google IO大会关于移动应用方面的主题有一些不错的PPT，对移动应用开发很有帮助。自己看了一些，边看边和大家分享。既然是PPT就很简化了，我会根据实际情况写一些Demo供大家参考。

Android在UI优化方面可以从以下五个方面入手：

• Adapter优化
• 背景和图片优化
• 绘图优化
• 视图和布局优化
• 内存分配优化

  二、Adapter优化

  什么是Adapter，可以先看看我的上一篇文章，Android开发——说说Adapter那点事 Adapter与View的连接主要依靠getView这个方法返回我们需要的自定义view。ListView是Android app中一个最最最常用的控件了，所以如何让ListView流畅运行，获取良好的用户体验是非常重要的。对ListView优化就是对Adapter中的getView方法进行优化。09年的Google IO大会给出的优化建议如下：

  Adapter优化示例代码：

     1: @Override

     2: public View getView(int position, View convertView, ViewGroup parent) {

     3:     Log.d("MyAdapter", "Position:" + position + "---"

     4:             + String.valueOf(System.currentTimeMillis()));

     5:     ViewHolder holder;

     6:     if (convertView == null) {

     7:         final LayoutInflater inflater = (LayoutInflater) mContext

     8:                 .getSystemService(Context.LAYOUT_INFLATER_SERVICE);

     9:         convertView = inflater.inflate(R.layout.list_item_icon_text, null);

    10:         holder = new ViewHolder();

    11:         holder.icon = (ImageView) convertView.findViewById(R.id.icon);

    12:         holder.text = (TextView) convertView.findViewById(R.id.text);

    13:         convertView.setTag(holder);

    14:     } else {

    15:         holder = (ViewHolder) convertView.getTag();

    16:     }

    17:     holder.icon.setImageResource(R.drawable.icon);

    18:     holder.text.setText(mData[position]);

    19:     return convertView;

    20: }

    21:  

    22: static class ViewHolder {

    23:     ImageView icon;

    24:  

    25:     TextView text;

    26: }

  以上是Google io大会上给出的优化建议，经过尝试ListView确实流畅了许多。
   

     1: @Override

     2:  public View getView(int position, View convertView, ViewGroup parent) {

     3:      Log.d("MyAdapter", "Position:" + position + "---"

     4:              + String.valueOf(System.currentTimeMillis()));

     5:          final LayoutInflater inflater = (LayoutInflater) mContext

     6:                  .getSystemService(Context.LAYOUT_INFLATER_SERVICE);

     7:          View v = inflater.inflate(R.layout.list_item_icon_text, null);

     8:          ((ImageView) v.findViewById(R.id.icon)).setImageResource(R.drawable.icon);

     9:          ((TextView) v.findViewById(R.id.text)).setText(mData[position]);

    10:         return v;

    11:  }

  以上是不建议的做法！！
   
  不过我们还是要怀疑一下，SO，我们还是来测试对比一下。
   
  测试说明：
  大家可以看到在getView的时候我们通过log打印出position和当前系统时间。我们通过初始化1000条数据到Adapter显示到ListView，然后滚动到底部，计算出position=0和position=999时的时间间隔。
  测试机子：HTC Magic
  测试实录：打开测序，让ListView一直滚动底部。:-)
• 
  测试结果：

  两种情况在操作过程中体验明显不同，在优化的情况下流畅很多很多！

  1、优化建议测试结果：

  12-05 10:44:46.039: DEBUG/MyAdapter(13929): Position:0---1291517086043 
  12-05 10:44:46.069: DEBUG/MyAdapter(13929): Position:1---1291517086072 
  12-05 10:44:46.079: DEBUG/MyAdapter(13929): Position:2---1291517086085

  ……

  12-05 10:45:04.109: DEBUG/MyAdapter(13929): Position:997---1291517104112 
  12-05 10:45:04.129: DEBUG/MyAdapter(13929): Position:998---1291517104135 
  12-05 10:45:04.149: DEBUG/MyAdapter(13929): Position:999---1291517104154

  耗时：17967

  2、没优化的测试结果

  12-05 10:51:42.569: DEBUG/MyAdapter(14131): Position:0---1291517502573 
  12-05 10:51:42.589: DEBUG/MyAdapter(14131): Position:1---1291517502590 
  12-05 10:51:42.609: DEBUG/MyAdapter(14131): Position:2---1291517502617

  ……

  12-05 10:52:07.079: DEBUG/MyAdapter(14131): Position:998---1291517527082 
  12-05 10:52:07.099: DEBUG/MyAdapter(14131): Position:999---1291517527108

  耗时：24535

  在1000条记录的情况下就有如此差距，一旦数据nW+，ListView的Item布局更加复杂的时候，优化的作用就更加突出了！

  OK，欢迎大家交流学习，Gtalk：ghanguo@gmail.com

  转载请注明出处！

  示例代码： GoogleIO示例代码

---------EOF------------------