• 【Android笔记05】Android基本的UI控件（ListView、RecyclerView、ViewPager）

    这篇文章，主要介绍Android中的基本UI控件，包含：ListView、RecyclerView、ViewPager。

    目录

    一、Android基本控件

    1.1、ListView

    （1）创建布局文件

    （2）创建自定义的Adapter类

    （3）创建数据集合

    （4）设置点击事件

    （5）Adapter优化

    1.2、RecyclerView

    （1）引入依赖

    （2）自定义Adapter

    （3）准备渲染数据

    （4）点击事件

    1.3、ViewPager

    （1）创建三个Activity活动页面

    （2）创建ViewPager布局

    （3）自定义Adapter

    （4）创建ViewPager

    一、Android基本控件

    1.1、ListView

    ListView是【Android】包下提供的一个列表控件，ListView类似于HTML里面的【li】标签，ListView控件里面可以包含其他的控件，ListView是一个容器，它里面可以包含的是每一项【item】列表项。

    如何使用ListView组件呢？？？我们要使用ListView组件，需要自定义相应的Adapter，然后在Adapter里面渲染相应的item项，下面我们来看下ListView具体使用。

    （1）创建布局文件

    • 我们在工程里面，创建【activity_main.xml】主页面布局。
    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.     
    7.     <!-- 定义 ListView 组件 -->
    8.     <ListView
    9.         android:id="@+id/lv01"
    10.         android:layout_width="match_parent"
    11.         android:layout_height="match_parent"/>
    12.     
    13. </LinearLayout>
    • 创建【activity_item.xml】列表项的布局文件。
    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.     
    7.     <!-- 创建列表项 -->
    8.     <TextView
    9.         android:id="@+id/tv01"
    10.         android:textSize="30sp"
    11.         android:layout_width="wrap_content"
    12.         android:layout_height="wrap_content"/>
    13.     
    14. </LinearLayout>

    （2）创建自定义的Adapter类

    我们自定义Adapter的时候，需要继承自【BaseAdapter】类，然后重写里面【4】个方法，每个方法的作用看代码注释。

    1. package com.android.app2.adapter;
    2.  
    3. import android.content.Context;
    4. import android.view.LayoutInflater;
    5. import android.view.View;
    6. import android.view.ViewGroup;
    7. import android.widget.BaseAdapter;
    8. import android.widget.TextView;
    9.  
    10. import com.android.app2.R;
    11. import com.android.app2.pojo.User;
    12.  
    13. import java.util.List;
    14.  
    15. public class MyListViewAdapter extends BaseAdapter {
    16.     
    17.     // 需要渲染的数据集合
    18.     private List<User> data;
    19.     // 上下文对象
    20.     private Context context;
    21.     
    22.     public MyListViewAdapter(List<User> data, Context context) {
    23.         this.data = data;
    24.         this.context = context;
    25.     }
    26.  
    27.     /**
    28.      * 这个方法就是获取需要渲染的item个数
    29.      * 即：ListView可以显示多少条数据
    30.      */
    31.     @Override
    32.     public int getCount() {
    33.         return data.size();
    34.     }
    35.  
    36.     // 根据下标获取到某个item项
    37.     @Override
    38.     public Object getItem(int position) {
    39.         return data.get(position);
    40.     }
    41.  
    42.     // 获取item对应的id
    43.     @Override
    44.     public long getItemId(int position) {
    45.         return position;
    46.     }
    47.  
    48.     /** 
    49.      * 这个就是渲染之后的item组件
    50.      * 每次渲染一条数据就会调用一次getView方法
    51.      * @param position 第几个item
    52.      * @param convertView 保存item项的容器组件
    53.      * @param parent 父容器组件
    54.      * @return
    55.      */
    56.     @Override
    57.     public View getView(int position, View convertView, ViewGroup parent) {
    58.         // 获取保存item项的容器组件
    59.         if (convertView == null) {
    60.             // 判空处理, 避免重复创建对象, 可以提高渲染效率
    61.             convertView = LayoutInflater.from(context).inflate(R.layout.activity_item, parent, false);
    62.         }
    63.         // 获取具体的列表项容器
    64.         TextView textView = convertView.findViewById(R.id.tv01);
    65.         // 将数据设置到 TextView 组件里面
    66.         User user = data.get(position);
    67.         textView.setText(user.getId()+ "----->" + user.getName());
    68.         return convertView;
    69.     }
    70. }

    （3）创建数据集合

    在【MainActivity】类里面，创建需要渲染的数据集合，并且获取ListView组件对象，将数据传递到ListView组件里面进行渲染。

    1. package com.android.app2;
    2.  
    3. import androidx.appcompat.app.AppCompatActivity;
    4.  
    5. import android.os.Bundle;
    6. import android.util.Log;
    7. import android.view.View;
    8. import android.widget.AdapterView;
    9. import android.widget.ListView;
    10.  
    11. import com.android.app2.adapter.MyListViewAdapter;
    12. import com.android.app2.pojo.User;
    13.  
    14. import java.util.ArrayList;
    15. import java.util.List;
    16.  
    17. public class MainActivity extends AppCompatActivity {
    18.  
    19.     @Override
    20.     protected void onCreate(Bundle savedInstanceState) {
    21.         super.onCreate(savedInstanceState);
    22.         setContentView(R.layout.activity_main);
    23.         // 创建数据集合
    24.         List<User> list = new ArrayList<>();
    25.         for (int i = 0; i < 50; i++) {
    26.             list.add(new User(1001 + i, "列表项" + (i + 1001)));
    27.         }
    28.         // 获取 ListView 组件, 传递数据进行渲染
    29.         ListView listView = findViewById(R.id.lv01);
    30.         // 设置 Adapter
    31.         listView.setAdapter(new MyListViewAdapter(list, this));
    32.     }
    33. }

    这个时候，我们其实就可以启动应用，查看效果了，如下所示。

     （4）设置点击事件

    我们可以给每个列表项设置点击事件，只需要通过【setOnItemClickListener】监听器，监听每一个item的点击操作即可。

    1. public class MainActivity extends AppCompatActivity {
    2.  
    3.     @Override
    4.     protected void onCreate(Bundle savedInstanceState) {
    5.         super.onCreate(savedInstanceState);
    6.         setContentView(R.layout.activity_main);
    7.         // 创建数据集合
    8.         List<User> list = new ArrayList<>();
    9.         for (int i = 0; i < 50; i++) {
    10.             list.add(new User(1001 + i, "列表项" + (i + 1001)));
    11.         }
    12.         // 获取 ListView 组件, 传递数据进行渲染
    13.         ListView listView = findViewById(R.id.lv01);
    14.         // 设置 Adapter
    15.         listView.setAdapter(new MyListViewAdapter(list, this));
    16.         
    17.         // 设置点击事件
    18.         listView.setOnItemClickListener(new AdapterView.OnItemClickListener() {
    19.             @Override
    20.             public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
    21.                 Log.i("ListView", "点击了第" + position + "个item项.");
    22.             }
    23.         });
    24.     }
    25. }

    再次启动应用，点击某一项，查看控制输出日志。

     通过点击事件，我们就可以获取到点击的那一项item，之后就可以进行更多的处理逻辑之类的。

    （5）Adapter优化

    在我们自定义的Adapter类里面，我们在调用【getView】方法的时候，里面写了【findViewById】方法来获取对应的容器组件，没渲染一次，都会调用一次【findViewById】方法，其实【findViewById】方法调用一次就可以了，没必要每次都调用，为了解决这个多次调用的问题，我们可以进行如下代码优化。

    • 将我们需要通过【findViewById】方法获取的组件，定义成一个全局变量，第一次渲染的时候，就将变量赋值，之后判断是否已经赋值了，如果已经赋值了，就不再进行调用【findViewById】方法。
    1. /**
    2.  * 这个就是渲染之后的item组件
    3.  * 每次渲染一条数据就会调用一次getView方法
    4.  * @param position 第几个item
    5.  * @param convertView 保存item项的容器组件
    6.  * @param parent 父容器组件
    7.  * @return
    8.  */
    9. @Override
    10. public View getView(int position, View convertView, ViewGroup parent) {
    11.     // 定义 ViewHolder
    12.     ViewHolder viewHolder;
    13.     // 获取保存item项的容器组件
    14.     if (convertView == null) {
    15.         // 初始化 ViewHolder 类
    16.         viewHolder = new ViewHolder();
    17.         // 判空处理, 避免重复创建对象, 可以提高渲染效率
    18.         convertView = LayoutInflater.from(context).inflate(R.layout.activity_item, parent, false);
    19.         // 获取 TextView 组件
    20.         // 获取具体的列表项容器
    21.         viewHolder.textView = convertView.findViewById(R.id.tv01);
    22.         // 将 ViewHolder 设置到当前View里面
    23.         convertView.setTag(viewHolder);
    24.     } else {
    25.         // 已经创建了, 直接从view里获取
    26.         viewHolder = (ViewHolder) convertView.getTag();
    27.     }
    28.     // 将数据设置到 TextView 组件里面
    29.     User user = data.get(position);
    30.     viewHolder.textView.setText(user.getId()+ "----->" + user.getName());
    31.     Log.i("ListView", "渲染item第" + position + "项.");
    32.     return convertView;
    33. }
    34.  
    35. // 创建自定义的 ViewHolder 类
    36. private final class ViewHolder {
    37.     TextView textView;
    38. }

    通过上面的代码优化之后，可以使得每次渲染ListView的时候，减少【findViewById】方法的调用，从而提高运行效率。因为调用【findViewById】方法会去解析【res】目录下的资源文件，然后将其作为每个对象返回，可以看到，【res】目录下的资源文件几乎都是不变的，所以一般情况下只需要解析一次就可以使用，没必须要每次都去解析。

    以上，就是ListView组件的相关使用。

    1.2、RecyclerView

    RecyclerView不是【Android】包下的组件，我们如果要使用RecyclerView组件，还需要额外的引入这个依赖。RecyclerView组件比ListView组件更加的灵活，RecyclerView允许我们自定义设置布局方式。

    RecyclerView是【Androidx】包下面的一个组件，需要引入如下依赖。

    （1）引入依赖

    • 首先，在项目里面的【Gradle Scripts】目录下面，找到我们对应的工程配置文件build.gradle，我的工程名称叫做【app2】，所以我就找到【build.gradle（app2）】的配置文件。

    •  打开配置文件，在里面的【dependencies】配置项中，添加RecyclerView的依赖。
    1. dependencies {
    2.     implementation 'androidx.recyclerview:recyclerview:1.2.1'
    3. }

    RecyclerView对应的版本自己选择即可，Android Studio一般都会有提示，直接选择对应版本即可。

    • 添加完成之后，重新更新一下Gradle，如下所示。

     点击同步之后，这个时候Gradle就会根据配置文件去下载对应的依赖。

    （2）自定义Adapter

    和前面介绍的ListView组件一样的，我们都需要自定义Adapter类，然后在Adapter类里面实现我们组件数据的渲染。不同的是，ListView需要我们自己去优化渲染，而RecyclerView则替我们封装好了优化渲染的判断逻辑，我们只需要实现相应的类即可。

    • 创建【MyRecyclerViewAdapter】类，继承自【RecyclerView.Adapter】类。
    1. package com.android.app2.adapter;
    2.  
    3. import android.content.Context;
    4. import android.view.View;
    5. import android.view.ViewGroup;
    6. import android.widget.TextView;
    7.  
    8. import androidx.annotation.NonNull;
    9. import androidx.recyclerview.widget.RecyclerView;
    10.  
    11. import com.android.app2.R;
    12. import com.android.app2.pojo.User;
    13.  
    14. import java.util.List;
    15.  
    16. public class MyRecyclerViewAdapter extends RecyclerView.Adapter<MyRecyclerViewAdapter.MyViewHolder> {
    17.  
    18.     /** 需要渲染的数据集合 */
    19.     private List<User> data;
    20.     /** 上下文对象 */
    21.     private Context context;
    22.  
    23.     public MyRecyclerViewAdapter(List<User> data, Context context) {
    24.         this.data = data;
    25.         this.context = context;
    26.     }
    27.  
    28.     /**
    29.      * 创建相应的 ViewHolder 对象
    30.      * @param parent
    31.      * @param viewType
    32.      * @return
    33.      */
    34.     @NonNull
    35.     @Override
    36.     public MyViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
    37.         // 获取对应的 item 组件View对象
    38.         View view = View.inflate(context, R.layout.activity_item, null);
    39.         // 创建 ViewHolder 对象
    40.         return new MyViewHolder(view);
    41.     }
    42.  
    43.     /**
    44.      * 填充渲染item的内容
    45.      * @param holder
    46.      * @param position
    47.      */
    48.     @Override
    49.     public void onBindViewHolder(@NonNull MyViewHolder holder, int position) {
    50.         User user = data.get(position);
    51.         // 设置需要渲染的数据内容
    52.         holder.textView.setText(user.getName() + "---->" + user.getId());
    53.     }
    54.  
    55.     /**
    56.      * 需要渲染的数据总数
    57.      * @return
    58.      */
    59.     @Override
    60.     public int getItemCount() {
    61.         return data != null ? data.size() : 0;
    62.     }
    63.  
    64.     public class MyViewHolder extends RecyclerView.ViewHolder {
    65.         private TextView textView;
    66.  
    67.         public MyViewHolder(@NonNull View itemView) {
    68.             super(itemView);
    69.             // 获取组件
    70.             textView = itemView.findViewById(R.id.tv01);
    71.         }
    72.     }
    73. }
    • 在【activity_main.xml】布局文件中，定义RecyclerView组件。
    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.     
    7.     <!-- 定义 RecyclerView 组件 -->
    8.     <androidx.recyclerview.widget.RecyclerView
    9.         android:id="@+id/tv01"
    10.         android:layout_width="match_parent"
    11.         android:layout_height="match_parent"/>
    12.  
    13. </LinearLayout>

    （3）准备渲染数据

    打开主页面对应的类【MainActivity】，在方法中添加测试数据，然后获取RecyclerView组件对象，设置渲染的数据，自定义布局。（注意：如果没有设置布局，那么运行的时候，看不到效果，只会出现一片空白）

    1. package com.android.app2;
    2.  
    3. import androidx.appcompat.app.AppCompatActivity;
    4. import androidx.recyclerview.widget.RecyclerView;
    5. import androidx.recyclerview.widget.LinearLayoutManager;
    6.  
    7. import android.os.Bundle;
    8. import com.android.app2.adapter.MyRecyclerViewAdapter;
    9. import com.android.app2.pojo.User;
    10.  
    11. import java.util.ArrayList;
    12. import java.util.List;
    13.  
    14. public class MainActivity extends AppCompatActivity {
    15.  
    16.     @Override
    17.     protected void onCreate(Bundle savedInstanceState) {
    18.         super.onCreate(savedInstanceState);
    19.         setContentView(R.layout.activity_main);
    20.         // 创建数据集合
    21.         List<User> list = new ArrayList<>();
    22.         for (int i = 0; i < 50; i++) {
    23.             list.add(new User(1001 + i, "列表项" + (i + 1001)));
    24.         }
    25.  
    26.         // 获取 RecyclerView 对象
    27.         RecyclerView recyclerView = findViewById(R.id.rv01);
    28.         // 设置自定义布局
    29.         LinearLayoutManager linearLayoutManager = new LinearLayoutManager(this);
    30.         recyclerView.setLayoutManager(linearLayoutManager);
    31.         // 创建自定义的 Adapter
    32.         MyRecyclerViewAdapter adapter = new MyRecyclerViewAdapter(list, this);
    33.         recyclerView.setAdapter(adapter);
    34.     }
    35. }

    启动应用，查看运行效果如下所示。

    从上面的运行效果可以看到，RecyclerView显示的样式和ListView还是有点不同的，ListView里面每个item之间都有边框，而RecyclerView则没有。

    上面采用的线性布局，我们也可以采用网格布局、瀑布流布局。

    • 采用网格布局，设置每一行显示【3】列。
    1. // 设置自定义布局
    2. GridLayoutManager gridLayoutManager = new GridLayoutManager(this, 3);
    3. recyclerView.setLayoutManager(gridLayoutManager);

    效果如下所示：

    • 设置瀑布流布局，一行显示【3】列，垂直方向显示。
    1. // 设置自定义布局
    2. StaggeredGridLayoutManager layoutManager = new StaggeredGridLayoutManager(3, LinearLayout.VERTICAL);
    3. recyclerView.setLayoutManager(layoutManager);

    运行效果如下所示：

    可以看到采用网格布局和瀑布流布局显示的效果怎么是一样的呢？？？其实是不一样，这里显示一样的原因是因为我们的数据太有规律了，子树都是一样长，导致两种布局看起来就是一样的效果。

    当我们的数据内容不一样的时候，这个时候就可以看到两种布局的区别了，我们修改一下数据来看看两种布局的区别。

     以上，就是网格布局和瀑布流布局的差别。

    （4）点击事件

    RecyclerView组件没有提供类似于ListView的【setOnItemClickListener】方法，我们需要自己去实现监听方法，一般我们会按照下面的方式进行监听方法的设置。

    • 在自定义的Adapter类里面的自定义的ViewHolder类里面，定义自定义监听方法，然后在ViewHolder构造方法里面进行回调。
    1.     public class MyViewHolder extends RecyclerView.ViewHolder {
    2.         private final TextView textView;
    3.  
    4.         public MyViewHolder(@NonNull View itemView) {
    5.             super(itemView);
    6.             // 获取组件
    7.             textView = itemView.findViewById(R.id.tv01);
    8.             // TODO 在这里通过 itemView 的点击事件，去回调自定义的点击事件
    9.             itemView.setOnClickListener(new View.OnClickListener() {
    10.                 @Override
    11.                 public void onClick(View v) {
    12.                     // TODO 这里回调自定义的点击事件
    13.                     if (itemClickListener != null) {
    14.                         // getAdapterPosition()方法已经过时了，建议我们去调用
    15. //                        itemClickListener.onRecyclerItemClick(getAdapterPosition());
    16.                         itemClickListener.onRecyclerItemClick(getAbsoluteAdapterPosition());
    17.                     }
    18.                 }
    19.             });
    20.         }
    21.     }
    22.  
    23.     /** 创建自定义的监听对象 */
    24.     private OnRecyclerItemClickListener itemClickListener;
    25.  
    26.     /** 这个就是提供给外部进行设置监听对象的 */
    27.     public void setRecyclerItemClickListener(OnRecyclerItemClickListener listener) {
    28.         this.itemClickListener = listener;
    29.     }
    30.  
    31.     /** 创建自定义监听接口 */
    32.     public interface OnRecyclerItemClickListener {
    33.         void onRecyclerItemClick(int position);
    34.     }
    • 在【MainActivity】类里面，设置监听事件。
    1. MyRecyclerViewAdapter adapter = new MyRecyclerViewAdapter(list, this);
    2. recyclerView.setAdapter(adapter);
    3. // 通过自定义的Adapter，设置监听点击事件
    4. adapter.setRecyclerItemClickListener(new MyRecyclerViewAdapter.OnRecyclerItemClickListener() {
    5.     @Override
    6.     public void onRecyclerItemClick(int position) {
    7.         // TODO 这个就是我们自定义的点击事件
    8.         Log.i("RecyclerView", "点击了第" + position + "项.");
    9.     }
    10. });
    • 启动应用，点击某个item项，查看控制台的输出日志。

     以上，就是RecyclerView组件的基本使用。

    1.3、ViewPager

    ViewPager组件是一个可以实现页面左右切换效果的组件，它是androidx包里面的组件。下面看下ViewPager组件的具体使用。

    （1）创建三个Activity活动页面

    ViewPager是一个页面切换的组件，所以这里我们创建三个活动页面，用于测试。

    • 创建【activity_page01.xml】。
    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.     android:background="#FFFFFF00">
    7.  
    8.     <!-- 创建列表项 -->
    9.     <TextView
    10.         android:id="@+id/tv01"
    11.         android:textSize="30sp"
    12.         android:text="第一个页面"
    13.         android:textColor="@color/black"
    14.         android:layout_width="wrap_content"
    15.         android:layout_height="wrap_content"/>
    16.  
    17. </LinearLayout>
    • 创建【activity_page02.xml】。
    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.     android:background="#FF00FF00">
    7.  
    8.     <!-- 创建列表项 -->
    9.     <TextView
    10.         android:id="@+id/tv01"
    11.         android:textSize="30sp"
    12.         android:text="第二个页面"
    13.         android:textColor="@color/black"
    14.         android:layout_width="wrap_content"
    15.         android:layout_height="wrap_content"/>
    16.  
    17. </LinearLayout>
    • 创建【activity_page03.xml】。
    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.     android:background="#FF00AAFF">
    7.  
    8.     <!-- 创建列表项 -->
    9.     <TextView
    10.         android:id="@+id/tv01"
    11.         android:textSize="30sp"
    12.         android:text="第三个页面"
    13.         android:textColor="@color/black"
    14.         android:layout_width="wrap_content"
    15.         android:layout_height="wrap_content"/>
    16.  
    17. </LinearLayout>

    （2）创建ViewPager布局

    在主页面的布局文件里面添加ViewPager组件。

    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.     
    7.     <!-- 定义 ViewPager 组件 -->
    8.     <androidx.viewpager.widget.ViewPager
    9.         android:id="@+id/vp01"
    10.         android:layout_width="match_parent"
    11.         android:layout_height="match_parent"/>
    12.  
    13. </LinearLayout>

    （3）自定义Adapter

    ViewPager组件需要自定义一个Adapter类，然后继承自【PagerAdapter】类，重写里面的方法，然后渲染每个页面。

    1. package com.android.app2.adapter;
    2.  
    3. import android.view.View;
    4. import android.view.ViewGroup;
    5.  
    6. import androidx.annotation.NonNull;
    7. import androidx.viewpager.widget.PagerAdapter;
    8.  
    9. import java.util.List;
    10.  
    11. public class MyViewPagerAdapter extends PagerAdapter {
    12.  
    13.     /** 有多少个页面 */
    14.     private List<View> data;
    15.     
    16.     public MyViewPagerAdapter(List<View> data) {
    17.         this.data = data;
    18.     }
    19.  
    20.     /**
    21.      * 获取有多少个页面
    22.      * @return
    23.      */
    24.     @Override
    25.     public int getCount() {
    26.         return data.size();
    27.     }
    28.  
    29.     /**
    30.      * 将给定的 position 组件添加到container容器里面，创建并显示
    31.      * 返回一个创建后的view的key值
    32.      * @param container
    33.      * @param position
    34.      * @return
    35.      */
    36.     @NonNull
    37.     @Override
    38.     public Object instantiateItem(@NonNull ViewGroup container, int position) {
    39.         // 添加View到容器
    40.         container.addView(data.get(position), 0);
    41.         return data.get(position);
    42.     }
    43.  
    44.     /**
    45.      * 判断 instantiateItem 方法返回的 view 和当前view是否同一个
    46.      * @param view
    47.      * @param object
    48.      * @return
    49.      */
    50.     @Override
    51.     public boolean isViewFromObject(@NonNull View view, @NonNull Object object) {
    52.         return view == object;
    53.     }
    54.  
    55.     /**
    56.      * 销毁view
    57.      * @param container
    58.      * @param position
    59.      * @param object
    60.      */
    61.     @Override
    62.     public void destroyItem(@NonNull ViewGroup container, int position, @NonNull Object object) {
    63.         // 移除某个View
    64.         container.removeView(data.get(position));
    65.     }
    66. }

    （4）创建ViewPager

    在【MainActivity】主页面类里面，我们准备需要显示的页面集合，然后通过自定义的Adapter进行页面布局的渲染。

    1.     @Override
    2.     protected void onCreate(Bundle savedInstanceState) {
    3.         super.onCreate(savedInstanceState);
    4.         setContentView(R.layout.activity_main);
    5.         // 获取 ViewPager 组件
    6.         ViewPager viewPager = findViewById(R.id.vp01);
    7.         // 创建数据
    8.         List<View> data = new ArrayList<>();
    9.         // 获取三个布局对象
    10.         LayoutInflater lf = getLayoutInflater().from(this);
    11.         View page01 = lf.inflate(R.layout.activity_page01, null);
    12.         View page02 = lf.inflate(R.layout.activity_page02, null);
    13.         View page03 = lf.inflate(R.layout.activity_page03, null);
    14.         data.add(page01);
    15.         data.add(page02);
    16.         data.add(page03);
    17.         // 创建自定义Adapter对象
    18.         MyViewPagerAdapter adapter = new MyViewPagerAdapter(data);
    19.         // 渲染
    20.         viewPager.setAdapter(adapter);
    21. 	}

    启动应用，查看ViewPager效果，左右滑动页面，可以发现页面来回切换。

     以上，就是ViewPager组件的相关使用。

    综上，这篇文章结束了，主要介绍了Android中的基本UI控件，包含：ListView、RecyclerView、ViewPager。

  • 相关阅读:
    java计算机毕业设计web扶贫产品物资管理平台源码+mysql数据库+系统+lw文档+部署
    大模型的视觉能力
    wpf datagrid 主从表关联查询
    【Redis】list常用命令&内部编码&使用场景
    Pytorch框架学习记录5——DataLoader的使用
    uniapp条件编辑语法
    springboot物流配货管理系统java
    PAM从入门到精通（十七）
    conda常用命令
    GlusterFS：开源分布式文件系统的深度解析与应用场景实践
  • 原文地址：https://blog.csdn.net/qq_39826207/article/details/125452463