ListView的万能适配器和ListView的多布局

最新推荐文章于 2018-10-19 18:13:58 发布
原创 最新推荐文章于 2018-10-19 18:13:58 发布 · 309 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#android  #adapter #ListView的万能适配器 #ListView的多布局

本文介绍了一种适用于ListView的通用适配器实现方案，包括单一布局和多布局的适配器，通过抽象类和接口定义了适配器的基本结构，并提供了具体的实现案例。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

ListView的万能适配器

CommomLvAdapter：

public abstract class CommomLvAdapter<T> extends BaseAdapter {

    private Context mContext;
    private List<T> mDataList;
    private int mLayoutId;

    public CommomLvAdapter(Context context, List<T> dataList, int layoutId) {
        mContext = context;
        mDataList = dataList;
        mLayoutId = layoutId;
    }

    public void refreshData(List<T> dataList) {
        this.mDataList = dataList;
        notifyDataSetChanged();
    }

    public void deleteList(int position) {
        this.mDataList.remove(position);
        this.notifyDataSetChanged();
    }


    @Override
    public int getCount() {
        return mDataList == null ? 0 : mDataList.size();
    }

    @Override
    public T getItem(int position) {
        return mDataList.get(position);
    }

    @Override
    public long getItemId(int position) {
        return position;
    }

    @Override
    public View getView(int position, View convertView, ViewGroup parent) {
        LvViewHolder holder = LvViewHolder.getHolder(mContext, convertView, parent, mLayoutId, position);
        T t = mDataList.get(position);
        convert(holder, t, position);
        return holder.getConvertView();
    }

    public abstract void convert(LvViewHolder holder, T itemData, int position);
}

LvViewHolder ：

public class LvViewHolder {

    private final View mConvertView;

    //Android开发中官方推荐：当使用HashMap(K, V),如果K为整数类型时,使用SparseArray的效率更高
    private SparseArray<View> mViews;

    private Context mContext;

    protected int mPosition;

    protected int mLayoutId;

    public LvViewHolder(Context context, View itemView, ViewGroup parent, int position) {
        this.mContext = context;
        this.mPosition = position;
        mConvertView = itemView;
        mViews = new SparseArray<>();
        mConvertView.setTag(this);
    }


    public static LvViewHolder getHolder(Context context, View convertView, ViewGroup parent, int layoutId, int position) {
        if (convertView == null) {
            View itemView = LayoutInflater.from(context).inflate(layoutId, parent, false);
            LvViewHolder holder = new LvViewHolder(context, itemView, parent, position);
            holder.mLayoutId = layoutId;
            return holder;
        } else {
            LvViewHolder holder = (LvViewHolder) convertView.getTag();
            holder.mPosition = position;
            return holder;
        }
    }

    public View getConvertView() {
        return mConvertView;
    }

    public int getPosition() {
        return mPosition;
    }

    public int getLayoutId() {
        return mLayoutId;
    }

    public void updatePosition(int position) {
        mPosition = position;
    }


    public <T extends View> T getView(int viewId) {
        View view = mViews.get(viewId);
        if (view == null) {
            view = mConvertView.findViewById(viewId);
            mViews.append(viewId, view);
        }
        return (T) view;
    }

    public LvViewHolder setText(int viewId, String text) {
        TextView view = getView(viewId);
        view.setText(text);
        return this;
    }

    public LvViewHolder setTextColor(int viewId, int color) {
        TextView view = getView(viewId);
        view.setTextColor(color);
        return this;
    }

    public LvViewHolder setTextColorRes(int viewId, int textColorRes) {
        TextView view = getView(viewId);
        view.setTextColor(mContext.getResources().getColor(textColorRes));
        return this;
    }

    public LvViewHolder setImageByUrl(int viewId, String imageUrl) {
        ImageView view = getView(viewId);
       /* Glide.with(mContext).load(url)
                .diskCacheStrategy(DiskCacheStrategy.ALL)
                .error(R.mipmap.ic_launcher)
                .placeholder(R.mipmap.ic_launcher)
                .into(view);*/
        Glide.with(mContext).load(imageUrl).into(view);
        return this;
    }

    public LvViewHolder setImageResource(int viewId, int resId) {
        ImageView view = getView(viewId);
        view.setImageResource(resId);
        return this;
    }

    public LvViewHolder setImageDrawable(int viewId, Drawable drawable) {
        ImageView view = getView(viewId);
        view.setImageDrawable(drawable);
        return this;
    }

    public LvViewHolder setImageBitmap(int viewId, Bitmap bitmap) {
        ImageView view = getView(viewId);
        view.setImageBitmap(bitmap);
        return this;
    }

    public LvViewHolder setBackgroundColor(int viewId, int color) {
        View view = getView(viewId);
        view.setBackgroundColor(color);
        return this;
    }

    public LvViewHolder setBackgroundRes(int viewId, int backgroundRes) {
        View view = getView(viewId);
        view.setBackgroundResource(backgroundRes);
        return this;
    }

    public LvViewHolder setVisible(int viewId, boolean visible) {
        View view = getView(viewId);
        view.setVisibility(visible ? View.VISIBLE : View.GONE);
        return this;
    }

    public LvViewHolder setOnClickListener(int viewId, View.OnClickListener listener) {
        View view = getView(viewId);
        view.setOnClickListener(listener);
        return this;
    }

    public LvViewHolder setOnTouchListener(int viewId, View.OnTouchListener listener) {
        View view = getView(viewId);
        view.setOnTouchListener(listener);
        return this;
    }

    public LvViewHolder setOnLongClickListener(int viewId, View.OnLongClickListener listener) {
        View view = getView(viewId);
        view.setOnLongClickListener(listener);
        return this;
    }

}

ListView的多布局

public class MutilLayoutAdapter extends BaseAdapter {

    public static final int TYPE1 = 0;// 3种不同的布局
    public static final int TYPE2 = 1;
    public static final int TYPE3 = 2;


    private Context mContext;

    private List<UserInfo> mDataList;

    private final LayoutInflater mLayoutInflater;

    public MutilLayoutAdapter(Context context, List<UserInfo> dataList) {
        mContext = context;
        mDataList = dataList;
        mLayoutInflater = LayoutInflater.from(context);
    }

    @Override
    public int getCount() {
        return mDataList == null ? 0 : mDataList.size();
    }

    @Override
    public Object getItem(int position) {
        return mDataList.get(position);
    }

    @Override
    public long getItemId(int position) {
        return position;
    }

    @Override
    public View getView(int position, View convertView, ViewGroup parent) {
        int type = mDataList.get(position).getType();
        BaseViewHolder baseViewHolder = null;
        if (convertView == null) {
            switch (type) {
                case TYPE1:
                    convertView = mLayoutInflater.inflate(R.layout.item_list1, parent, false);
                    baseViewHolder = new ViewHolder1(convertView);
                    break;
                case TYPE2:
                    convertView = mLayoutInflater.inflate(R.layout.item_list2, parent, false);
                    baseViewHolder = new ViewHolder2(convertView);
                    break;
                case TYPE3:
                    convertView = mLayoutInflater.inflate(R.layout.item_list3, parent, false);
                    baseViewHolder = new ViewHolder3(convertView);
                    break;
            }
            convertView.setTag(baseViewHolder); //关联convertView和ViewHolder
        } else {
            baseViewHolder = (BaseViewHolder) convertView.getTag();
        }

        //填充数据
        UserInfo userInfo = mDataList.get(position);
        fillData(type, baseViewHolder, userInfo);
        return convertView;
    }

    private void fillData(int type, BaseViewHolder baseViewHolder, UserInfo userInfo) {
        switch (type) {
            case TYPE1:
                fillDataType1(baseViewHolder, userInfo);
                break;
            case TYPE2:
                fillDataType2(baseViewHolder, userInfo);
                break;
            case TYPE3:
                fillDataType3(baseViewHolder, userInfo);
                break;
        }
    }

    private void fillDataType1(BaseViewHolder baseViewHolder, UserInfo userInfo) {
        ViewHolder1 holder = (ViewHolder1) baseViewHolder;
        holder.tvName.setText(userInfo.getName());
    }

    private void fillDataType2(BaseViewHolder baseViewHolder, UserInfo userInfo) {
        ViewHolder2 holder = (ViewHolder2) baseViewHolder;
        holder.tvName.setText(userInfo.getName());
        holder.tvDesc.setText(userInfo.getDesc());
    }

    private void fillDataType3(BaseViewHolder baseViewHolder, UserInfo userInfo) {
        ViewHolder3 holder = (ViewHolder3) baseViewHolder;
        holder.tvName.setText(userInfo.getName());
        holder.tvDesc.setText(userInfo.getDesc());
        holder.tvTime.setText(userInfo.getTime());
    }


    /**
     * 返回某個位置item布局类型
     *
     * @param position
     * @return
     */
    @Override
    public int getItemViewType(int position) {
        return mDataList.get(position).getType();
    }

    /**
     * 返回item布局类型的个数
     *
     * @return
     */
    @Override
    public int getViewTypeCount() {
        return 3;
    }

    static class BaseViewHolder {

    }

    static class ViewHolder1 extends BaseViewHolder {

        private TextView tvName;

        public ViewHolder1(View convertView) {
            tvName = convertView.findViewById(R.id.tv_name);
        }
    }

    static class ViewHolder2 extends BaseViewHolder {
        private TextView tvName;
        private TextView tvDesc;

        public ViewHolder2(View convertView) {
            tvName = convertView.findViewById(R.id.tv_name);
            tvDesc = convertView.findViewById(R.id.tv_desc);
        }
    }


    static class ViewHolder3 extends BaseViewHolder {
        private TextView tvName;
        private TextView tvDesc;
        private TextView tvTime;

        public ViewHolder3(View convertView) {
            tvName = convertView.findViewById(R.id.tv_name);
            tvDesc = convertView.findViewById(R.id.tv_desc);
            tvTime = convertView.findViewById(R.id.tv_time);
        }
    }
}


public class MainActivity extends AppCompatActivity {

    private ListView mListView;

    private List<UserInfo> mDataList = new ArrayList<>();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mListView = (ListView) findViewById(R.id.listview);

        Random r = new Random();
        for (int i = 1; i <= 50; i++) {
            int type = r.nextInt(3); //随机设置类型
            UserInfo userInfo = new UserInfo();
            userInfo.setName("标题" + i);
            userInfo.setDesc("这是一段描述内容");
            userInfo.setTime("2019-03-14");
            userInfo.setType(type);
            mDataList.add(userInfo);
        }

        MutilLayoutAdapter mutilLayoutAdapter = new MutilLayoutAdapter(this, mDataList);
        mListView.setAdapter(mutilLayoutAdapter);
    }
 }

ListView多布局适配器的封装

public class CommomMultiLvAdapter<T> extends BaseAdapter {

    protected Context mContext;
    protected List<T> mDatas;

    private ItemViewDelegateManager mItemViewDelegateManager;


    public CommomMultiLvAdapter(Context context, List<T> datas) {
        this.mContext = context;
        this.mDatas = datas;
        mItemViewDelegateManager = new ItemViewDelegateManager();
    }

    public CommomMultiLvAdapter addItemViewDelegate(ItemViewDelegate<T> itemViewDelegate) {
        mItemViewDelegateManager.addDelegate(itemViewDelegate);
        return this;
    }

    private boolean useItemViewDelegateManager() {
        return mItemViewDelegateManager.getItemViewDelegateCount() > 0;
    }

    @Override
    public int getViewTypeCount() {
        if (useItemViewDelegateManager()) {
            return mItemViewDelegateManager.getItemViewDelegateCount();
        }
        return super.getViewTypeCount();
    }

    @Override
    public int getItemViewType(int position) {
        if (useItemViewDelegateManager()) {
            int viewType = mItemViewDelegateManager.getItemViewType(mDatas.get(position), position);
            return viewType;
        }
        return super.getItemViewType(position);
    }

    @Override
    public View getView(int position, View convertView, ViewGroup parent) {
        ItemViewDelegate itemViewDelegate = mItemViewDelegateManager.getItemViewDelegate(mDatas.get(position), position);
        int layoutId = itemViewDelegate.getItemViewLayoutId();
        LvViewHolder viewHolder = null;
        if (convertView == null) {
            View itemView = LayoutInflater.from(mContext).inflate(layoutId, parent, false);
            viewHolder = new LvViewHolder(mContext, itemView, parent, position);
            viewHolder.mLayoutId = layoutId;
            onViewHolderCreated(viewHolder, viewHolder.getConvertView());
        } else {
            viewHolder = (LvViewHolder) convertView.getTag();
            viewHolder.mPosition = position;
        }

        convert(viewHolder, getItem(position), position);
        return viewHolder.getConvertView();
    }

    protected void convert(LvViewHolder viewHolder, T item, int position) {
        mItemViewDelegateManager.convert(viewHolder, item, position);
    }

    public void onViewHolderCreated(LvViewHolder holder, View itemView) {
    }

    @Override
    public int getCount() {
        return mDatas.size();
    }

    @Override
    public T getItem(int position) {
        return mDatas.get(position);
    }

    @Override
    public long getItemId(int position) {
        return position;
    }
}


public interface ItemViewDelegate<T> {

    int getItemViewLayoutId();

    boolean isForViewType(T item, int position);

    void convert(LvViewHolder holder, T t, int position);
}


public class ItemViewDelegateManager<T> {
    SparseArrayCompat<ItemViewDelegate<T>> delegates = new SparseArrayCompat();

    public int getItemViewDelegateCount() {
        return delegates.size();
    }

    public ItemViewDelegateManager<T> addDelegate(ItemViewDelegate<T> delegate) {
        int viewType = delegates.size();
        if (delegate != null) {
            delegates.put(viewType, delegate);
            viewType++;
        }
        return this;
    }

    public ItemViewDelegateManager<T> addDelegate(int viewType, ItemViewDelegate<T> delegate) {
        if (delegates.get(viewType) != null) {
            throw new IllegalArgumentException(
                    "An ItemViewDelegate is already registered for the viewType = "
                            + viewType
                            + ". Already registered ItemViewDelegate is "
                            + delegates.get(viewType));
        }
        delegates.put(viewType, delegate);
        return this;
    }

    public ItemViewDelegateManager<T> removeDelegate(ItemViewDelegate<T> delegate) {
        if (delegate == null) {
            throw new NullPointerException("ItemViewDelegate is null");
        }
        int indexToRemove = delegates.indexOfValue(delegate);

        if (indexToRemove >= 0) {
            delegates.removeAt(indexToRemove);
        }
        return this;
    }

    public ItemViewDelegateManager<T> removeDelegate(int itemType) {
        int indexToRemove = delegates.indexOfKey(itemType);

        if (indexToRemove >= 0) {
            delegates.removeAt(indexToRemove);
        }
        return this;
    }

    public int getItemViewType(T item, int position) {
        int delegatesCount = delegates.size();
        for (int i = delegatesCount - 1; i >= 0; i--) {
            ItemViewDelegate<T> delegate = delegates.valueAt(i);
            if (delegate.isForViewType(item, position)) {
                return delegates.keyAt(i);
            }
        }
        throw new IllegalArgumentException(
                "No ItemViewDelegate added that matches position=" + position + " in data source");
    }

    public void convert(LvViewHolder holder, T item, int position) {
        int delegatesCount = delegates.size();
        for (int i = 0; i < delegatesCount; i++) {
            ItemViewDelegate<T> delegate = delegates.valueAt(i);

            if (delegate.isForViewType(item, position)) {
                delegate.convert(holder, item, position);
                return;
            }
        }
        throw new IllegalArgumentException(
                "No ItemViewDelegateManager added that matches position=" + position + " in data source");
    }


    public int getItemViewLayoutId(int viewType) {
        return delegates.get(viewType).getItemViewLayoutId();
    }

    public int getItemViewType(ItemViewDelegate itemViewDelegate) {
        return delegates.indexOfValue(itemViewDelegate);
    }

    public ItemViewDelegate getItemViewDelegate(T item, int position) {
        int delegatesCount = delegates.size();
        for (int i = delegatesCount - 1; i >= 0; i--) {
            ItemViewDelegate<T> delegate = delegates.valueAt(i);
            if (delegate.isForViewType(item, position)) {
                return delegate;
            }
        }
        throw new IllegalArgumentException(
                "No ItemViewDelegate added that matches position=" + position + " in data source");
    }

    public int getItemViewLayoutId(T item, int position) {
        return getItemViewDelegate(item, position).getItemViewLayoutId();
    }
}

使用

public class MainActivity extends AppCompatActivity {

    private ListView mListView;

    private List<UserInfo> mDataList = new ArrayList<>();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mListView = (ListView) findViewById(R.id.listview);

        Random r = new Random();
        for (int i = 1; i <= 50; i++) {
            int type = r.nextInt(3); //随机设置类型
            UserInfo userInfo = new UserInfo();
            userInfo.setName("标题" + i);
            userInfo.setDesc("这是一段描述内容");
            userInfo.setTime("2019-03-14");
            userInfo.setType(type);
            mDataList.add(userInfo);
        }

        MultiAdapter multiAdapter=new MultiAdapter(this,mDataList);
        mListView.setAdapter(multiAdapter);


    }

    class MultiAdapter extends CommomMultiLvAdapter<UserInfo> {

        public MultiAdapter(Context context, List<UserInfo> datas) {
            super(context, datas);
            addItemViewDelegate(new Type1ItemDelagate());
            addItemViewDelegate(new Type2ItemDelagate());
            addItemViewDelegate(new Type3ItemDelagate());
        }
    }

    class Type1ItemDelagate implements ItemViewDelegate<UserInfo> {

        @Override
        public int getItemViewLayoutId() {
            return R.layout.item_list1;
        }

        @Override
        public boolean isForViewType(UserInfo item, int position) {
            return false;
        }

        @Override
        public void convert(LvViewHolder holder, UserInfo userInfo, int position) {
            holder.setText(R.id.tv_name, userInfo.getName());
        }
    }

    class Type2ItemDelagate implements ItemViewDelegate<UserInfo> {

        @Override
        public int getItemViewLayoutId() {
            return R.layout.item_list2;
        }

        @Override
        public boolean isForViewType(UserInfo item, int position) {
            return false;
        }

        @Override
        public void convert(LvViewHolder holder, UserInfo userInfo, int position) {
            holder.setText(R.id.tv_name, userInfo.getName());
            holder.setText(R.id.tv_desc, userInfo.getDesc());
        }
    }

    class Type3ItemDelagate implements ItemViewDelegate<UserInfo> {

        @Override
        public int getItemViewLayoutId() {
            return R.layout.item_list3;
        }

        @Override
        public boolean isForViewType(UserInfo item, int position) {
            return false;
        }

        @Override
        public void convert(LvViewHolder holder, UserInfo userInfo, int position) {
            holder.setText(R.id.tv_name, userInfo.getName());
            holder.setText(R.id.tv_desc, userInfo.getDesc());
            holder.setText(R.id.tv_time, userInfo.getTime());
        }
    }
}

参考博客
https://blog.youkuaiyun.com/lmj623565791/article/details/38902805

listview万能适配器
06-28
一个通用的适配器`BaseCommAdapter<T>，非常简单，继承该`BaseCommAdapter<T>`，利用泛型传入item对应数据的javabean类，我们只需要重写3个方法即可（其中有一个还是构造方法）。
ListView万能适配器
10-28
ListView ,GridView万能适配器
Android—万能ListView适配器
weixin_30907523的博客
08-16 142
ListView是开发中最常用的控件了，但是总是会写重复的代码，浪费时间又没有意义。 最近参考一些资料，发现一个万能ListView适配器，代码量少，节省时间，总结一下分享给大家。 首先有一个自定义的Adapter继承于BaseAdapter，下面是自定义的Adapter，精华在getView()方法中 package com.example.mylistview.util; im...
封装一个ListView万能适配器
雪中的烈焰
10-19 323
刚开始接触android的时候，有些东西并不会在意，可能自己并没有写太多的原因，随着项目越来越大，我们重复的工作做得越来越多，这个时候我们就会想着怎么才能简化我们的代码，android中的ListView用的还是很多的，所以就做了一个简化的万能适配器Adapter，主要就是利用JAVA中的命令模式进行开发的，如果有特别的功能，可自行在代码里添加修改，这只是单布局，多布局也差不多，也就是传入布局id...
ListView 万能适配器
qq_18877377的博客
07-23 350
最经在写项目ListView 写了好多个adapter也写了好多个，代码冗余太重。感觉好麻烦，这两天有时间，于是在网上找到了抽取程度高的万能适配器。仔细看了下代码感觉以前太low了。
详解xamarin Android 实现ListView万能适配器
08-29
通过使用ListView万能适配器，我们可以轻松地实现不同的ListView布局，并且可以极大地提高ListView的性能。 本文主要介绍了xamarin Android 实现ListView万能适配器的相关知识点，包括ViewHolder的实现、泛型...
Android ListView万能适配器实例代码
01-20
为了应对这个问题，开发者通常会创建一个“万能适配器”（Universal Adapter），它能够适应多种不同的视图类型，从而减少代码的冗余。 在这个实例中，我们看到一个名为`CommonAdapter`的自定义适配器，它是基于`...
android之listview万能适配器
07-09
"android之listview万能适配器"概念旨在创建一个通用、灵活的适配器，能够适应各种不同的数据结构和界面需求。以下将详细解析这个主题。 1. **适配器的作用**： - 适配器是`ListView`与数据模型之间的桥梁，它将...
Android之listview万能适配器
重心开始，重新开始
07-10 677
什么叫万能适配器，其实就是这种适配器是万能的，所有需要使用适配器的组件，都可用这一个适配器就行。 既然这样，就来讲讲吧。 先来看看效果图： 当然了，这只是很简单的例子，很简单的布局，这里只是用来做个例子，以后也可以写别的布局，这个适配器都是适用的~ 那我们就来讲讲怎么从普通的适配器到万能适配器的吧~ 步骤： 1.首先普通的适配器的写法是--MyAda
打造万能的ListView适配器（ViewHolder+CommonAdapter）
02-07
打造万能的ListView适配器（ViewHolder+CommonAdapter）
ListView万能适配器（半成品）
leng_wen_rou的博客
06-19 411
在慕课上看到大神的ListView万能适配 自己试着做了下   由于本人是一个菜鸟所以只能完成省略ViewHolder    创建一个ViewHolder工具类 继承BaseAdapter 详细代码如下  public class ViewHolder {     private SparseArray mViews;     private int
Android之打造ListView的万能适配器
wei_zhi的博客
11-02 1424
一、Android适配器简介在Android中，适配器扮演者重要的角色，是UI与Data实现绑定的一个桥梁。Adapter负责创建和显示每个项目的子View和提供对下层数据的访问。支持Adapter绑定的UI控件必须扩展AdapterView抽象类。二、传统的ListView适配器写法我们一向写的自定义适配器，就是继承ArrayAdapter，或者继承自BaseAdapter，然后重写4个方法，前三
为ListView打造万能适配器
xyTianZhao
12-21 1463
一、概述        该适配器主要还是对adapter和viewholder进行了抽象和封装，使之能够在任何item下都可以运用。 二、ViewHolder类 package com.tianzhao.myutils.adapter; import android.content.Context; import android.graphics.Bitmap; import androi
Android打造ListView万能适配器
const_qiu的专栏
05-22 568
打造ListView万能适配器 看到这里，想必你已经意识到每次新创建一个适配器需要重复写的代码实在太多，太浪费时间了。因此打造一个万能的listview适配器就显得重要了。在这里只要按照下面步骤创建好适配器类，那么当我们需要使用新的listview的时候，真正要写的代码就单单相当于你的item数据项条目了（这是每个适配器不同的地方），其他重复的代码无需再写了。是不是已经准好了，当然如果你想真正理
Android打造listview万能适配器（上）
Fly~~~的专栏
12-31 2694
来自：http://www.imooc.com/learn/372 一般情况下我们要在listview控件上展示自定义的数据，我们需要定义一个listview，然后对每个listview设置一个适配器adapter，一般继承自BaseAdapter，在每个适配器中我们都要定义一个viewholder，但是当我们有很多的listview时，这种做法就比较麻烦了，这时候我们就需要抽象出一个共同的适配器
ListView_适配器之万能适配器_实现多个ListView公用同一个适配器
roll圈圈的博客
09-17 1858
相信接触过开发的人一定会接触ListView，相信接触过ListView的人一定接触过BaseAdapter，相信接触过BaseAdapter的人一定很痛恨编写适配器，因为它的数量往往跟ListView的总数是成正比的，所以我今天给大家介绍一款神器，万能适配器！     在自定义适配器的时候，我们通常会自定义一个ViewHolder类，虽然这个名字是随便起的，但是就像约定俗成一样，我们还是这
打造万能的Listview适配器
DamonJiang的博客
01-05 758
本篇文章主要用来记录自己在开发当中常用的ListView控件适配器问题，因为在一个项目中有很多地方使用的listview控件的适配器都是可以复用的，但是我们不能在项目中到处新建Adapter，这样显得我们的代码冗余比较高，看起来比较繁琐，那么我们就需要抽取一个万能的BaseAdapter出来，这样在项目使用的地方只需要继承我们这个基类BaseAdapter就可以了，只需要传入我们关心的数据以及数据
ListView万能适配器实现与CheckedTextView兼容性解析
## 标题知识点 ...综上，开发者在使用“listview万能适配器”时，可以期待它将为多种不同场景下的ListView展示提供高效、简洁的解决方案，同时避免了为每种不同数据类型或布局设计特定适配器的繁琐工作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值