ListView、AdapterView、RecyclerView全面解析

快来打我* 2022-07-13 04:51 206阅读 0赞

原文链接：[http://blog.csdn.net/carson\_ho/article/details/51472640][http_blog.csdn.net_carson_ho_article_details_51472640]

![20160521215250214][]

# **AdapterView简介** #

AdapterView本身是一个抽象类，AdapterView及其子类的继承关系如下图：

![AdapterView][]

特征：

*  AdapterView继承自ViewGroup，本质是个容器
 *  AdapterView可以包含多个“列表项”，并将这多个列表项以合适的形式展示
 *  AdapterView显示的列表项内容由Adapter提供
 *  它派生的子类在用法上也基本相似，只是在显示上有一定区别，因此把他们也归为一类。
 *  由AdapterView直接派生的三个类：

AbsListView、AbsSpinner、AdapterViewAnimator

都是抽象类，所以我们用的最多的也就是图中第四行及以下的子类。

# **ListView简介** #

## **1. 什么是ListView** ##

即列表视图，是Android开发中一种常用的视图组件

## **2. ListView的作用** ##

将所要展示的数据集合起来  
以列表的形式展示到用户界面上

## **3. 关于Adapter** ##

*  定义：适配器
 *  作用：作为View和数据之间的桥梁

由于ListView和所要展现的数据是分开的，不直接接触，所以，Adapter的作用是把数据映射到ListView上，作为中介的作用，如下图

![Adapter][]

## **3. ListView的工作原理** ##

ListView、GridView、Spinner等AdapterView都只是容器，主要用于装载要显示的数据和显示数据，而Apdater负责提供容器的内容

即AdapterView负责采用合适的方式显示Adapter提供的内容。  
在运行时，当需要显示数据时，ListView会针对数据项向Adapter取出数据，从而加载到界面上。

试想下这么一个场景：如果把所有数据集合的信息都加载到View上，如果ListView要为每个数据都创建一个视图，那么会占用非常多的内存  
从上面可知，ListView不会为每一个数据创建一个视图，为了节省空间和时间，Android采用了一个叫Recycler的组件。

工作原理：当屏幕需要显示x个item时，那么ListView只会创建x+1个视图，当第一个item离开屏幕时，此item的view就会被拿来重用（用于显示下一个item（即第x+1个）的内容）。

## **工作原理实例** ##

假如屏幕只能显示7个item，那么ListView只会创建（7+1）个item的视图。当第1个item离开屏幕时，此item的view就会被拿来重用（用于显示第8个item的内容）。原理如下图显示

![ListView][]

# **ListView的使用** #

## **1. 生成方式** ##

生成列表视图（ListView）的方式主要有两种：

*  直接用ListView进行创建
 *  让Activity继承ListActivity

## **2. xml文件配置信息** ##

## **AbsListView的常用属性和相关方法** ##

<table> 
 <thead> 
  <tr> 
   <th align="left">属性</th> 
   <th align="left">说明</th> 
   <th align="left">备注</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">android:choiceMode</td> 
   <td align="left">列表的选择行为，默认：none没有选择行为</td> 
   <td align="left">选择方式： none：不显示任何选中项 singleChoice：允许单选multipleChoice：允许多选multipleChoiceModal：允许多选 （把Activity里面adapter的第二个参数改成支持选择的布局）</td> 
  </tr> 
  <tr> 
   <td align="left">android:drawSelectorOnTop</td> 
   <td align="left"></td> 
   <td align="left">如果该属性设置为true，选中的列表项将会显示在上面</td> 
  </tr> 
  <tr> 
   <td align="left">android:listSelector</td> 
   <td align="left">为点击到的Item设置图片</td> 
   <td align="left">如果该属性设置为true，选中的列表项将会显示在上面</td> 
  </tr> 
  <tr> 
   <td align="left">android：fastScrollEnabled</td> 
   <td align="left">设置是否允许快速滚动</td> 
   <td align="left">如果该属性设置为true，将会显示滚动图标，并允许用户拖动该滚动图标进行快速滚动。</td> 
  </tr> 
  <tr> 
   <td align="left">android：listSelector</td> 
   <td align="left">指定被选中的列表项上绘制的Drawable</td> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left">android：scrollingCache</td> 
   <td align="left">滚动时是否使用缓存</td> 
   <td align="left">如果设置为true，则在滚动时将会使用缓存</td> 
  </tr> 
  <tr> 
   <td align="left">android：stackFromBottom</td> 
   <td align="left">设置是否从底端开始排列列表项</td> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left">android：transcriptMode</td> 
   <td align="left">指定列表添加新的选项的时候，是否自动滑动到底部，显示新的选项。</td> 
   <td align="left">disabled：取消transcriptMode模式；默认的normal：当接受到数据集合改变的通知，并且仅仅当最后一个选项已经显示在屏幕的时候，自动滑动到底部。 alwaysScroll：无论当前列表显示什么选项，列表将会自动滑动到底部显示最新的选项。</td> 
  </tr> 
 </tbody> 
</table>

## Listview提供的XML属性： ##

<table> 
 <thead> 
  <tr> 
   <th align="left">XML属性</th> 
   <th align="left">说明</th> 
   <th align="left">备注</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">android:divider</td> 
   <td align="left">设置List列表项的分隔条（可用颜色分割，也可用图片（Drawable）分割</td> 
   <td align="left">不设置列表之间的分割线，可设置属性为@null</td> 
  </tr> 
  <tr> 
   <td align="left">android:dividerHeight</td> 
   <td align="left">用于设置分隔条的高度</td> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left">android:background属性</td> 
   <td align="left">设置列表的背景</td> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left">android：entries</td> 
   <td align="left">指定一个数组资源，Android将根据该数组资源来生成ListView</td> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left">android：footerDividerEnabled</td> 
   <td align="left">如果设置成false，则不在footer View之前绘制分隔条</td> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left">andorid：headerDividerEnabled</td> 
   <td align="left">如果设置成false，则不再header View之前绘制分隔条</td> 
   <td align="left"></td> 
  </tr> 
 </tbody> 
</table>

# **Adapter介绍** #

Adapter本身是一个接口，Adapter接口及其子类的继承关系如下图：

![Adapter][Adapter 1]

Adapter接口派生了ListAdapter和SpinnerAdapter两个子接口

其中ListAdapter为AbsAdapter提供列表项，而SpinnerAdapter为AbsSpinner提供列表项

ArrayAdapter、SimpleAdapter、SimpleCursorAdapter、BaseAdapter都是常用的实现适配器的类

*  ArrayAdapter：简单、易用的Adapter，用于将数组绑定为列表项的数据源，支持泛型操作
 *  SimpleAdapter：功能强大的Adapter，用于将XML中控件绑定为列表项的数据源
 *  SimpleCursorAdapter：与SimpleAdapter类似，用于绑定游标（直接从数据数取出数据）作为列表项的数据源
 *  BaseAdapter：可自定义ListView，通用用于被扩展。扩展BaseAdapter可以对各个列表项进行最大程度的定制。

# 常用适配器介绍 #

## 1. ArrayAdapter ##

定义：简单、易用的Adapter，用于将数组绑定为列表项的数据源，支持泛型操作

## 步骤 ##

1、 在xml文件布局上实现ListView

<?xml version="1.0" encoding="utf-8"?>
    <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent" android:layout_height="match_parent" android:paddingBottom="@dimen/activity_vertical_margin" android:paddingLeft="@dimen/activity_horizontal_margin" android:paddingRight="@dimen/activity_horizontal_margin" android:paddingTop="@dimen/activity_vertical_margin" tools:context="com.example.carson_ho.adapte_demo.MainActivity">
    
        <ListView android:id="@+id/list_item" android:layout_width="match_parent" android:layout_height="match_parent" android:divider="#f00" android:dividerHeight="1sp" android:headerDividersEnabled="false">
        </ListView>
    </RelativeLayout>

2、 在MainActivity上定义一个链表，将所要展示的数据以存放在里面  
3、 构造ArrayAdapter对象，设置适配器  
4、 将LsitView绑定到ArrayAdapter上

![20160521215826049][]

public class MainActivity extends AppCompatActivity {      
    
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
    
           ListView listView = (ListView) findViewById(R.id.list_item);
            //定义一个链表用于存放要显示的数据
            final List<String> adapterData = new ArrayList<String>();
            //存放要显示的数据
            for (int i = 0; i < 20; i++) {
                adapterData.add("ListItem" + i);
            }
            //创建ArrayAdapter对象adapter并设置适配器
             ArrayAdapter<String> adapter = new ArrayAdapter<String>(this,
                    android.R.layout.simple_list_item_1, adapterData);
            //将LsitView绑定到ArrayAdapter上
            listView.setAdapter(adapter);
        }
    }

创建ArrayAdapter对象要指定三个参数:

*  context：代表方位Android应用的接口
 *  textViewRseourceld：资源ID，代表一个TextView
 *  数组：列表项展示的数据

5、 在xml文件布局添加资源文件TextView,该TextView组件将作列表项的组件

<?xml version="1.0" encoding="utf-8"?>
    
    <TextView xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="match_parent" android:layout_height="wrap_content">
        android:textSize="24sp"
    </TextView>

最终效果图

![20160521220011536][]

缺点：ArrayAdapter较为简单，易用，但每个列表项只能是TextView，功能实现的局限性非常大。

## 2. SimpleAdapter ##

定义：功能强大的Adapter，用于将XML中控件绑定作为列表项的数据源

特点：可对每个列表项进行定制（自定义布局），能满足大多数开发的需求场景，灵活性较大

步骤  
1、 在xml文件布局上实现ListView

2、 根据实际需求定制列表项：实现ListView每行的xml布局（即item布局）

<?xml version="1.0" encoding="utf-8"?>
    <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="match_parent" android:layout_height="match_parent">
    
        <TextView android:id="@+id/name" android:layout_width="wrap_content" android:layout_height="wrap_content" android:paddingLeft="14dp" android:textSize="17sp"/>
    
        <TextView android:id="@+id/address" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_below="@id/name" android:textSize="17sp"/>
    
        <TextView android:id="@+id/lowerest_wholesale" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_toRightOf="@id/address" android:textSize="17sp"/>
    
        <TextView android:id="@+id/price" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_below="@id/address" android:textSize="17sp"/>
    
        <ImageView android:id="@+id/picture" android:layout_width="115dp" android:layout_height="86dp" android:layout_alignParentRight="true"/>
    </RelativeLayout>

3、 定义一个HashMap构成的列表以键值对的方式存放数据  
4、 构造SimpleAdapter对象，设置适配器  
5、 将LsitView绑定到SimpleAdapter上

public class MainActivity extends AppCompatActivity { 
            //定义数组以填充数据
            private String[] name=new String[]{
                    "威龙注塑机","霸龙注塑机","恐龙注塑机"    };
            private String[] address =new String[]{
                    "广东","北京","黑龙江"    };
            private int[] lowerest_wholesale =new int[]{
                    11,22,33    };
            private int[] price =new int[]{
                    11,22,33    };
            private int[] picture =new int[]{
                    R.drawable.home_selected,
                    R.drawable.home_selected,
                    R.drawable.home_selected   };
    
            @Override
            protected void onCreate(Bundle savedInstanceState) {
                super.onCreate(savedInstanceState);
                setContentView(R.layout.activity_main);
    
                //定义一个HashMap构成的列表以键值对的方式存放数据
                ArrayList<HashMap<String, Object>> listItem = new ArrayList<HashMap<String,Object>>();
                //循环填充数据 
                for(int i=0;i<name.length;i++)        {
                    HashMap<String,Object> map = new HashMap<String,Object>();
                    map.put("name", name[i]);
                    map.put("address", address[i]);
                    map.put("lowerest_wholesale", lowerest_wholesale[i]);
                    map.put("price", price[i]);
                    map.put("picture", picture[i]);
                    listItem.add(map);
                }
    
                //构造SimpleAdapter对象，设置适配器 
                SimpleAdapter mSimpleAdapter = new SimpleAdapter(this,
                        listItem,//需要绑定的数据 
                        R.layout.item_imformation,//每一行的布局 
                        new String[] {
       "name","address", "lowerest_wholesale","price","picture"},
                        //数组中的数据源的键对应到定义布局的View中 
                        new int[] {R.id.name,R.id.address,R.id.lowerest_wholesale,R.id.price,R.id.picture});
                ListView list= (ListView) findViewById(R.id.list_item);
                //为ListView绑定适配器 
                list.setAdapter(mSimpleAdapter);
            }
        }

结果显示

![20160521220041521][]

# BaseAdapter #

定义：可自定义ListView，通用用于被扩展。扩展BaseAdapter可以对各个列表项进行最大程度的定制

使用步骤：

*  定义主xml布局
 *  根据需要定义ListView每行所实现的xml布局
 *  定义一个Adapter类继承BaseAdapter，重写里面的方法。
 *  定义一个HashMap构成的列表，将数据以键值对的方式存放在里面。
 *  构造Adapter对象，设置适配器。
 *  将LsitView绑定到Adapter上。

先定义一个Adapter类继承BaseAdapter，并重写里面的方法

使用BaseAdapter必须写一个类继承它，同时BaseAdapter是一个抽象类，继承它必须实现它的方法。

class MyAdapter extends BaseAdapter {
        private LayoutInflater mInflater;//得到一个LayoutInfalter对象用来导入布局
    
     //构造函数
        public MyAdapter(Context context,ArrayList<HashMap<String, Object>> listItem) {
            this.mInflater = LayoutInflater.from(context);
            this.listItem = listItem;
        }//声明构造函数
    
        @Override
        public int getCount() {
            return listItem.size();
        }//这个方法返回了在适配器中所代表的数据集合的条目数
    
        @Override
        public Object getItem(int position) {
            return listItem.get(position);
        }//这个方法返回了数据集合中与指定索引position对应的数据项
    
        @Override
        public long getItemId(int position) {
            return position;
        }//这个方法返回了在列表中与指定索引对应的行id
    
    
        @Override
        public View getView(int position, View convertView, ViewGroup parent) {
            return null;
        }//这个方法返回了指定索引对应的数据项的视图，还没写完
    }

这里主要讲一下BaseAdapter里必须要重写的4个方法

*  BaseAdapter的灵活性就在于它要重写很多方法，其中最重要的即为getView()方法。
 *  我们结合上述重写的4个方法了解下系统绘制ListView的原理：

当系统开始绘制ListView的时候，首先调用getCount()方法。得到它的返回值，即ListView的长度。

系统调用getView()方法，根据这个长度逐一绘制ListView的每一行。（如果让getCount()返回1，那么只显示一行）。

getItem()和getItemId()则在需要处理和取得Adapter中的数据时调用。

那么getView()如何使用呢？如果有10000行数据，就绘制10000次？这肯定会极大的消耗资源，导致ListView滑动非常的慢，那应该怎么做呢？可以使用BaseAdapter进行优化ListView的显示。

以下将使用4种重写方法来说明getView()的使用

## 重写getView()的第一种方法 ##

@Override
        public View getView(int position, View convertView, ViewGroup parent) {
            View item = mInflater.inflate(R.layout.item,null);
            ImageView img = (ImageView)item.findViewById(R.id.ItemImage);
            TextView title = (TextView)item.findViewById(R.id.ItemTitle);
            TextView test = (TextView)item.findViewById(R.id.ItemText);
            Button btn = (Button) item.findViewById(R.id.ItemBottom);
            img.setImageResource((Integer) listItem.get(position).get("ItemImage"));
            title.setText((String) listItem.get(position).get("ItemTitle"));
            test.setText((String) listItem.get(position).get("ItemText"));
    
            return item;
        }//这个方法返回了指定索引对应的数据项的视图

这种方法每次getView()都要findViewById和重新绘制一个View，当列表项数据量很大的时候会严重影响性能，造成下拉很慢，所以数据量大的时候不推荐用这种方式。

重写getView()的第二种方法：使用convertView作为缓存进行优化  
getView()返回值是一个View，把它作为输入参数并放到getView()输入参数里，形成反馈。这样就形成了Adapter的itemView重用机制，减少了重绘View的次数。

@Override
        public View getView(int position, View convertView, ViewGroup parent) {
            if(convertView == null)
            {
                convertView = mInflater.inflate(R.layout.item, null);
            }//检测有没有可以重用的View，没有就重新绘制
            ImageView img = (ImageView)convertView.findViewById(R.id.ItemImage);
            TextView title = (TextView)convertView.findViewById(R.id.ItemTitle);
            TextView test = (TextView)convertView.findViewById(R.id.ItemText);
            Button btn = (Button) convertView.findViewById(R.id.ItemBottom);
            img.setImageResource((Integer) listItem.get(position).get("ItemImage"));
            title.setText((String) listItem.get(position).get("ItemTitle"));
            test.setText((String) listItem.get(position).get("ItemText"));
    
            return convertView;
        }//这个方法返回了指定索引对应的数据项的视图

这种方法和第一种相比减少了重绘View的次数，但是还是每一次都要findViewById

## 重写getView()第三种方法 ##

通过convertView+ViewHolder来实现缓存进而进行优化  
convertView缓存了View，ViewHolder相当于更加具体的缓存：View里的组件，即把View和View的组件一并进行缓存，那么重用View的时候就不用再重绘View和View的组件（findViewById）

static class ViewHolder
        {
            public ImageView img;
            public TextView title;
            public TextView text;
            public Button btn;
        }//声明一个外部静态类
        @Override
        public View getView(int position, View convertView, ViewGroup parent) {
            ViewHolder holder ;
            if(convertView == null)
            {
                holder = new ViewHolder();
                convertView = mInflater.inflate(R.layout.item, null);
                holder.img = (ImageView)convertView.findViewById(R.id.ItemImage);
                holder.title = (TextView)convertView.findViewById(R.id.ItemTitle);
                holder.text = (TextView)convertView.findViewById(R.id.ItemText);
                holder.btn = (Button) convertView.findViewById(R.id.ItemBottom);
                convertView.setTag(holder);
            }
            else {
                holder = (ViewHolder)convertView.getTag();
    
            }
            holder.img.setImageResource((Integer) listItem.get(position).get("ItemImage"));
            holder.title.setText((String) listItem.get(position).get("ItemTitle"));
            holder.text.setText((String) listItem.get(position).get("ItemText"));
    
            return convertView;
        }//这个方法返回了指定索引对应的数据项的视图

这种方法就既减少了重绘View，又减少了findViewById的次数，所以这种方法是最能节省资源的，所以非常推荐大家使用通过convertView+ViewHolder来重写getView()

利用convertView+ViewHolder来重写getView()的实现BaseAdapter的具体实现代码：

定义主xml的布局 activity\_main.xml:

<?xml version="1.0" encoding="utf-8"?>
    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent" android:layout_height="match_parent" android:background="#FFFFFF" android:orientation="vertical" >
        <ListView android:id="@+id/listView1" android:layout_width="match_parent" android:layout_height="match_parent" />
    </LinearLayout>

根据需要，定义ListView每行所实现的xml布局（item布局） item.xml:

<?xml version="1.0" encoding="utf-8"?>
    <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="match_parent" android:layout_height="match_parent">
        <ImageView android:layout_alignParentRight="true" android:layout_width="wrap_content" android:layout_height="wrap_content" android:id="@+id/ItemImage"/>
        <Button android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="按钮" android:id="@+id/ItemBottom" android:focusable="false" android:layout_toLeftOf="@+id/ItemImage" />
        <TextView android:id="@+id/ItemTitle" android:layout_height="wrap_content" android:layout_width="fill_parent" android:textSize="20sp"/>
        <TextView android:id="@+id/ItemText" android:layout_height="wrap_content" android:layout_width="fill_parent" android:layout_below="@+id/ItemTitle"/>
    </RelativeLayout>

定义一个Adapter类继承BaseAdapter，重写里面的方法。 （利用convertView+ViewHolder来重写getView()）

MyAdapter.java

package scut.learnlistview;
    
    import android.content.Context;
    import android.view.LayoutInflater;
    import android.view.View;
    import android.view.ViewGroup;
    import android.widget.BaseAdapter;
    import android.widget.Button;
    import android.widget.ImageView;
    import android.widget.TextView;
    
    import java.util.ArrayList;
    import java.util.HashMap;
    
    /** * Created by yany on 2016/4/11. */
    class MyAdapter extends BaseAdapter {
        private LayoutInflater mInflater;//得到一个LayoutInfalter对象用来导入布局 
        ArrayList<HashMap<String, Object>> listItem;
    
        public MyAdapter(Context context,ArrayList<HashMap<String, Object>> listItem) {
            this.mInflater = LayoutInflater.from(context);
            this.listItem = listItem;
        }//声明构造函数
    
        @Override
        public int getCount() {
            return listItem.size();
        }//这个方法返回了在适配器中所代表的数据集合的条目数
    
        @Override
        public Object getItem(int position) {
            return listItem.get(position);
        }//这个方法返回了数据集合中与指定索引position对应的数据项
    
        @Override
        public long getItemId(int position) {
            return position;
        }//这个方法返回了在列表中与指定索引对应的行id
    
    //利用convertView+ViewHolder来重写getView()
        static class ViewHolder
        {
            public ImageView img;
            public TextView title;
            public TextView text;
            public Button btn;
        }//声明一个外部静态类
        @Override
        public View getView(final int position, View convertView, final ViewGroup parent) {
            ViewHolder holder ;
            if(convertView == null)
            {
                holder = new ViewHolder();
                convertView = mInflater.inflate(R.layout.item, null);
                holder.img = (ImageView)convertView.findViewById(R.id.ItemImage);
                holder.title = (TextView)convertView.findViewById(R.id.ItemTitle);
                holder.text = (TextView)convertView.findViewById(R.id.ItemText);
                holder.btn = (Button) convertView.findViewById(R.id.ItemBottom);
                convertView.setTag(holder);
            }
            else {
                holder = (ViewHolder)convertView.getTag();
    
            }
            holder.img.setImageResource((Integer) listItem.get(position).get("ItemImage"));
            holder.title.setText((String) listItem.get(position).get("ItemTitle"));
            holder.text.setText((String) listItem.get(position).get("ItemText"));
            holder.btn.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    System.out.println("你点击了选项"+position);//bottom会覆盖item的焦点，所以要在xml里面配置android:focusable="false"
                }
            });
    
            return convertView;
        }//这个方法返回了指定索引对应的数据项的视图
    }

4、在MainActivity里：

*  定义一个HashMap构成的列表，将数据以键值对的方式存放在里面。
 *  构造Adapter对象，设置适配器。
 *  将LsitView绑定到Adapter上。

MainActivity.java

package scut.learnlistview;
    
    import android.support.v7.app.AppCompatActivity;
    import android.os.Bundle;
    import android.view.View;
    import android.widget.AdapterView;
    import android.widget.ArrayAdapter;
    import android.widget.ListView;
    import android.widget.SimpleAdapter;
    
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    
    public class MainActivity extends AppCompatActivity { 
        private ListView lv;
    
        @Override
        public void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
    
            lv = (ListView) findViewById(R.id.listView1);
            /*定义一个以HashMap为内容的动态数组*/
            ArrayList<HashMap<String, Object>> listItem = new ArrayList<HashMap<String, Object>>();/*在数组中存放数据*/
            for (int i = 0; i < 100; i++) {
                HashMap<String, Object> map = new HashMap<String, Object>();
                map.put("ItemImage", R.mipmap.ic_launcher);//加入图片
                map.put("ItemTitle", "第" + i + "行");
                map.put("ItemText", "这是第" + i + "行");
                listItem.add(map);
            }
            MyAdapter adapter = new MyAdapter(this, listItem);
            lv.setAdapter(adapter);//为ListView绑定适配器
    
            lv.setOnItemClickListener(new AdapterView.OnItemClickListener() {
                @Override
                public void onItemClick(AdapterView<?> arg0, View arg1, int arg2, long arg3) {
                    System.out.println("你点击了第" + arg2 + "行");//设置系统输出点击的行
                }
            });
    
    }
    }

运行结果

![20160521220152615][]

点击输出结果：

![这里写图片描述][20160521220208521]

# **RecyclerView介绍** #

## **1. 定义** ##

RecyclerView是Google推出用来代替ListView组件的，是一个强大的滑动组件。  
RecyclerView强制使用了ViewHolder，直接把viewholder的实现封装起来，用户只要实现自己的viewholder就可以了，该组件会自动帮你回收复用每一个item。

## **2. 工作原理** ##

当屏幕需要显示x个item时，那么ListView只会创建x+1个视图，当第一个item离开屏幕时，此item的view就会被拿来重用（用于显示下一个item（即第x+1个）的内容）。

## **3. 工作原理实例** ##

![RecyclerView][]

## **4. RecyclerView的重要概念介绍** ##

### RecyclerView.Adapter ###

和ListView一样，RecyclerView一样需要适配器，而且这个适配器强制要求了我们必须要用Viewholder，让性能得到优化，而且getView方法不需自己写，我们只需要写好Viewholder，View的复用已经封装好了。

### LayoutManager ###

管理布局，设置为LinearLayoutManager、GridLayoutManager、StaggeredGridLayoutManager可以轻易地实现ListView，GridView以及流式布局的列表效果。它还可以管理滚动和循环利用。

### ItemAnimator ###

这个类可以实现增删动画，而且不想设置的话它的默认效果已经很好了。

## 5. 优缺点 ##

优点 ： 有了ListView、GridView为什么还需要RecyclerView这样的控件呢？优点在于

*  item复用性高  
    把ViewHolder的实现封装起来，规范了ViewHolder，把item的view写入ViewHolder中，可以通过复用ViewHolder来实现view的复用
 *  灵活、可定制化高、可拓展性高  
    整体上看RecyclerView架构，提供了一种插拔式的体验：高度的解耦，异常的灵活：
 *  控制其显示的方式-通过布局管理器LayoutManager
 *  控制Item间的间隔（可绘制）-通过ItemDecoration
 *  控制Item增删的动画- 通过ItemAnimator

mRecyclerView = findView(R.id.id_recyclerview);
    //设置布局管理器
    mRecyclerView.setLayoutManager(layout);
    //设置adapter
    mRecyclerView.setAdapter(adapter)
    //设置Item增加、移除动画
    mRecyclerView.setItemAnimator(new DefaultItemAnimator());
    //添加分割线
    mRecyclerView.addItemDecoration(new DividerItemDecoration(
                    getActivity(), DividerItemDecoration.HORIZONTAL_LIST));

问：相比较于ListView，RecyclerView基本需要上面一系列步骤进行设置，而ListView可能只需要去设置一个adapter就能正常使用。那么为什么会添加这么多的步骤呢？

答：从名字上看RecyclerView，即回收循环视图，也就是说RecyclerView只管回收与复用View，其他的你可以自己去设置，可以看出其高度的解耦，给予你充分的定制自由

缺点： RecyclerView实现控制点击、长按事件较为麻烦，需要自己写

使用实例

使用RecyclerView的步骤：

*  定义主xml布局
 *  根据需要定义RecyclerView每行所实现的xml布局
 *  定义一个Adapter类继承RecyclerView.Adapter，重写里面的方法。
 *  定义一个HashMap构成的列表，将数据以键值对的方式存放在里面。
 *  构造Adapter对象，设置适配器。
 *  将RecyclerView绑定到Adapter上。

Demo的源码下载：[https://github.com/Carson-Ho/RecyclerView][https_github.com_Carson-Ho_RecyclerView]

个人推荐先fork下来再对着下面的分析看，效果会更好哦！

步骤1. 定义主xml布局

activity\_main.xml

在AndroidStudio1.5使用support-v7包：

*  右键文件目录的app目录进入Moudle Setting
 *  在Dependencies里面加入com.android.support:recyclerview-v7:23.1.1包。

步骤2. 根据需要定义RecyclerView每行所实现的xml布局（item布局）

list\_cell.xml

<?xml version="1.0" encoding="utf-8"?>
    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:orientation="vertical" android:layout_width="match_parent" android:layout_height="match_parent">
    <RelativeLayout android:layout_width="match_parent" android:layout_height="match_parent">
        <ImageView android:layout_alignParentRight="true" android:layout_width="wrap_content" android:layout_height="wrap_content" android:id="@+id/ItemImage"/>
        <TextView android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="New Text" android:id="@+id/Itemtitle" />
    
        <TextView android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="New Text" android:id="@+id/Itemtext" android:layout_below="@+id/Itemtitle"/>
    </RelativeLayout>
    </LinearLayout>

步骤3. 定义一个Adapter类继承 RecyclerView.Adapter，重写里面的方法。

MyAdapter.Java

package scut.receiverview;
    
    import android.content.Context;
    import android.support.v7.widget.RecyclerView;
    import android.view.LayoutInflater;
    import android.view.View;
    import android.view.ViewGroup;
    import android.widget.ImageView;
    import android.widget.TextView;
    
    import java.util.ArrayList;
    import java.util.HashMap;
    
    /** * Created by yany on 2016/4/11. */
    public class MyAdapter extends RecyclerView.Adapter { 
        private LayoutInflater inflater;
        private ArrayList<HashMap<String, Object>> listItem;
        private MyItemClickListener myItemClickListener;
    
        public MyAdapter(Context context, ArrayList<HashMap<String, Object>> listItem) {
            inflater = LayoutInflater.from(context);
            this.listItem = listItem;
        }//构造函数，传入数据
    
    
        //定义Viewholder
        class Viewholder extends RecyclerView.ViewHolder  {
            private TextView Title, Text;
            private ImageView ima;
    
            public Viewholder(View root) {
                super(root);
                Title = (TextView) root.findViewById(R.id.Itemtitle);
                Text = (TextView) root.findViewById(R.id.Itemtext);
                ima = (ImageView) root.findViewById(R.id.ItemImage);
                root.setOnClickListener(new View.OnClickListener() {
                    @Override
                    public void onClick(View v) {
                        if (myItemClickListener != null)
                            myItemClickListener .onItemClick(v,getPosition());
                    }
    
                }//监听到点击就回调MainActivity的onItemClick函数
                );
    
            }
    
            public TextView getTitle() {
                return Title;
            }
    
            public TextView getText() {
                return Text;
            }
    
            public ImageView getIma() {
                return ima;
            }
    
    
        }
    
            @Override
            public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
                return new Viewholder(inflater.inflate(R.layout.list_cell, null));
            }//在这里把ViewHolder绑定Item的布局
    
            @Override
            public void onBindViewHolder(RecyclerView.ViewHolder holder, final int position) {
                Viewholder vh = (Viewholder) holder;
                vh.Title.setText((String) listItem.get(position).get("ItemTitle"));
                vh.Text.setText((String) listItem.get(position).get("ItemText"));
                vh.ima.setImageResource((Integer) listItem.get(position).get("ItemImage"));
            }//在这里绑定数据到ViewHolder里面
    
            @Override
            public int getItemCount() {
                return listItem.size();
            }//返回Item数目
    
            public void setOnItemClickListener(MyItemClickListener listener){
            myItemClickListener = listener;
            }//绑定MainActivity传进来的点击监听器
    }

实现点击事件:

1.  在Viewholder里面设置了点击事件监听器
2.  通过调用OnItemClickListener的接口方法回调MainActivity里的方法。

MyItemClickListener.java接口：用来实现点击事件

package scut.receiverview;
    
    import android.view.View;
    
    
    public interface MyItemClickListener { 
        public void onItemClick(View view,int postion);
    }

步骤4：在MainActicity.java里：

*  定义一个HashMap构成的列表，将数据以键值对的方式存放在里面。
 *  构造Adapter对象，设置适配器
 *  将RecyclerView绑定到Adapter上

MainActicity.java

package scut.receiverview;
    
    import android.os.Bundle;
    import android.support.v7.app.AppCompatActivity;
    import android.support.v7.widget.LinearLayoutManager;
    import android.support.v7.widget.RecyclerView;
    import android.view.View;
    import android.widget.Toast;
    
    import java.util.ArrayList;
    import java.util.HashMap;
    
    public class MainActivity extends AppCompatActivity implements MyItemClickListener { 
        private RecyclerView Rv;
        private ArrayList<HashMap<String,Object>> listItem;
        private MyAdapter myAdapter;
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            initData();
            initView();
    
        }
    
        public void initData(){
            listItem = new ArrayList<HashMap<String, Object>>();/*在数组中存放数据*/
            for (int i = 0; i < 100; i++) {
                HashMap<String, Object> map = new HashMap<String, Object>();
                map.put("ItemTitle", "第" + i + "行");
                map.put("ItemText", "这是第" + i + "行");
                map.put("ItemImage",R.mipmap.ic_launcher);
                listItem.add(map);
            }
        }
        public void initView(){
          //为ListView绑定适配器
          myAdapter = new MyAdapter(this,listItem);
          myAdapter.setOnItemClickListener(this);
          Rv.setAdapter(myAdapter);  
    
         Rv = (RecyclerView) findViewById(R.id.my_recycler_view);
            //使用线性布局
            LinearLayoutManager layoutManager = new LinearLayoutManager(this);
            Rv.setLayoutManager(layoutManager);
            Rv.setHasFixedSize(true);
            Rv.addItemDecoration(new DividerItemDecoration(this, layoutManager.getOrientation()));//用类设置分割线
    //Rv.addItemDecoration(new DividerItemDecoration(this, R.drawable.list_divider)); //用已有图片设置分割线
    
    
        }
    
        @Override
        public void onItemClick(View view, int postion) {
       //点击事件的回调函数
            System.out.println("点击了第"+postion+"行");
            Toast.makeText(this, (String)listItem.get(postion).get("ItemText"), Toast.LENGTH_SHORT).show();
        }
    
    }

1.  最后是一个步骤是实现分割线ItemDecoration

如果自己画了分割线就可以直接添上去，不需要写这个类

DividerItemDecoration.java:

package scut.receiverview;
    
    import android.content.Context;
    import android.graphics.Canvas;
    import android.graphics.Color;
    import android.graphics.Paint;
    import android.graphics.Rect;
    import android.support.v7.widget.LinearLayoutManager;
    import android.support.v7.widget.RecyclerView;
    import android.util.TypedValue;
    import android.view.View;
    
    
    public class DividerItemDecoration extends RecyclerView.ItemDecoration { 
        /* * RecyclerView的布局方向，默认先赋值 * 为纵向布局 * RecyclerView 布局可横向，也可纵向 * 横向和纵向对应的分割想画法不一样 * */
        private int mOrientation = LinearLayoutManager.VERTICAL ;
    
        /** * item之间分割线的size，默认为1 */
        private int mItemSize = 1 ;
    
        /** * 绘制item分割线的画笔，和设置其属性 * 来绘制个性分割线 */
        private Paint mPaint ;
    
        /** * 构造方法传入布局方向，不可不传 * @param context * @param orientation */
        public DividerItemDecoration(Context context,int orientation) {
            this.mOrientation = orientation;
            if(orientation != LinearLayoutManager.VERTICAL && orientation != LinearLayoutManager.HORIZONTAL){
                throw new IllegalArgumentException("请传入正确的参数") ;
            }
            mItemSize = (int) TypedValue.applyDimension(mItemSize, TypedValue.COMPLEX_UNIT_DIP,context.getResources().getDisplayMetrics());
            mPaint = new Paint(Paint.ANTI_ALIAS_FLAG) ;
            mPaint.setColor(Color.BLUE);
             /*设置填充*/
            mPaint.setStyle(Paint.Style.FILL);
        }
    
        @Override
        public void onDraw(Canvas c, RecyclerView parent, RecyclerView.State state) {
            if(mOrientation == LinearLayoutManager.VERTICAL){
                drawVertical(c,parent) ;
            }else {
                drawHorizontal(c,parent) ;
            }
        }
    
        /** * 绘制纵向 item 分割线 * @param canvas * @param parent */
        private void drawVertical(Canvas canvas,RecyclerView parent){
            final int left = parent.getPaddingLeft() ;
            final int right = parent.getMeasuredWidth() - parent.getPaddingRight() ;
            final int childSize = parent.getChildCount() ;
            for(int i = 0 ; i < childSize ; i ++){
                final View child = parent.getChildAt( i ) ;
                RecyclerView.LayoutParams layoutParams = (RecyclerView.LayoutParams) child.getLayoutParams();
                final int top = child.getBottom() + layoutParams.bottomMargin ;
                final int bottom = top + mItemSize ;
                canvas.drawRect(left,top,right,bottom,mPaint);
            }
        }
    
        /** * 绘制横向 item 分割线 * @param canvas * @param parent */
        private void drawHorizontal(Canvas canvas,RecyclerView parent){
            final int top = parent.getPaddingTop() ;
            final int bottom = parent.getMeasuredHeight() - parent.getPaddingBottom() ;
            final int childSize = parent.getChildCount() ;
            for(int i = 0 ; i < childSize ; i ++){
                final View child = parent.getChildAt( i ) ;
                RecyclerView.LayoutParams layoutParams = (RecyclerView.LayoutParams) child.getLayoutParams();
                final int left = child.getRight() + layoutParams.rightMargin ;
                final int right = left + mItemSize ;
                canvas.drawRect(left,top,right,bottom,mPaint);
            }
        }
    
        /** * 设置item分割线的size * @param outRect * @param view * @param parent * @param state */
        @Override
        public void getItemOffsets(Rect outRect, View view, RecyclerView parent, RecyclerView.State state) {
            if(mOrientation == LinearLayoutManager.VERTICAL){
                outRect.set(0,0,0,mItemSize);
            }else {
                outRect.set(0,0,mItemSize,0);
            }
        }
    }

效果输出图

![20160521220606450][]

# 总结 #

本文对ListView、AdapterView、RecyclerView进行了全面整理，接下来我会介绍继续介绍Android开发中的相关知识，有兴趣可以继续关注Carson\_Ho的安卓开发笔记

[http_blog.csdn.net_carson_ho_article_details_51472640]: http://blog.csdn.net/carson_ho/article/details/51472640
[20160521215250214]: /images/20220713/98ee703d3b59487eb542c512b1a94c0d.png
[AdapterView]: /images/20220713/5db3854a4b904f489144a07bb5b3d8ca.png
[Adapter]: /images/20220713/07ad26e4cbba4a5aa9fc25d643472ca3.png
[ListView]: /images/20220713/7c8f4ce03e4744c5aff5b668538b8a81.png
[Adapter 1]: /images/20220713/2b3c11fbec1947c39d60fba2f47f387a.png
[20160521215826049]: /images/20220713/f6adaf88f5c6468da8b126a1dcc79566.png
[20160521220011536]: /images/20220713/3a6e25d41bb94f8681dfca5e6a0e46d8.png
[20160521220041521]: /images/20220713/428b945478b241469954b0ecaacf91c6.png
[20160521220152615]: /images/20220713/29552fb296b3429e897636f880302dc7.png
[20160521220208521]: /images/20220713/e3464e6bba2b4cd9a7f00f6768fa0715.png
[RecyclerView]: /images/20220713/2b3aa5aab29b460ea26f64fac42642f9.png
[https_github.com_Carson-Ho_RecyclerView]: https://github.com/Carson-Ho/RecyclerView
[20160521220606450]: /images/20220713/973adfa16d0747d0a49384c1b73b0aab.png