一个优化极点的ViewHolder

代码中有注释:

使用方法:

1.可以在listview,gridview,stageView直接继承LazyAdapter使用

2.下面有Demo 代码

ViewHolder代码:

import android.content.Context;
import android.util.SparseArray;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;

/**
* holder处理的事情
* 1.处理item的每个点击事件,具体业务由adapter来实现
* 2.封装每个item的单一数据
*
* @param <T> T为当前item的单一数据
*/
public class SmartViewHolder<T> implements View.OnClickListener {
//封装item的所有view
private final SparseArray<View>   mViews      = new SparseArray<View>();
private final SparseArray<Object> notifyFlags = new SparseArray<Object>();
//当前item的数据
private       T              currentData;
private final LazyAdapter<T> adapter;
private       View           mConvertView;

private SmartViewHolder(Context context, ViewGroup parent, int layoutId, T currentData, LazyAdapter<T> adapter) {
mConvertView = LayoutInflater.from(context).inflate(layoutId, parent, false);
mConvertView.setTag(this);
this.currentData = currentData;
this.adapter = adapter;
}

public T getCurrentData() {
return currentData;
}

public void setCurrentData(T currentData) {
this.currentData = currentData;
}

/**
* SmartViewHolder 单例操作
*
* @param context
* @param convertView
* @param currentData
* @param parent
* @param layoutId
* @return holder instance
*/
public static <T> SmartViewHolder<T> obtainHolder(Context context, View convertView, T currentData, ViewGroup parent, int layoutId, LazyAdapter<T> adapter) {

if (convertView == null) {
return new SmartViewHolder<T>(context, parent, layoutId, currentData, adapter);
}
SmartViewHolder<T> holder = (SmartViewHolder<T>) convertView.getTag();
holder.currentData = currentData;
return holder;
}

/**
* 获取item指定view
*
* @param viewId view's id
*/
public <V extends View> V getView(int viewId) {
return getView(viewId, false);
}

/**
* 获取item指定view
*
* @param viewId        view's id
* @param hasClickEvent 如果该view不需要click事件 false
*/
public <V extends View> V getView(int viewId, boolean hasClickEvent) {
View view = mViews.get(viewId);
if (view == null) {
view = mConvertView.findViewById(viewId);
mViews.put(viewId, view);
if (hasClickEvent) {
view.setOnClickListener(this);
}
}
return (V) view;
}

/**
* 添加需要click的view
* @param views  可变参数,view's id
*/
public void requestClickEvent(int... views) {
for (int item : views) {
getView(item, true);
}
}

@Override
public void onClick(View v) {
//回调holder指定view的click事件
transferClickEvent(v, currentData);
}

/**
* 回调holder的点击事件,具体业务实现在adapter
* @param view
* @param currentData
*/
private void transferClickEvent(View view, T currentData) {
adapter.handleClick(this, view, currentData);
}

/**
* @return rootView
*/
public View getConvertView() {
return mConvertView;
}

/**
* 1.数据显示完成后,用holder记住view正在显示的数据,
* 下次notify时,如果数据没有变化,则不用再次显示
* 2.如果该view的数据发生变化,则需要调用updateShowingData()更新变化的数据
*
* @param view
* @param data
* @return
*/
public boolean showingDataChanged(View view, Object data) {
return !(notifyFlags.get(view.getId()) != null &&
notifyFlags.get(view.getId()).equals(data));
}

/**
* 如果该view的数据发生变化,则需要调用该方法来更新变化的数据
*
* @param view
* @param data
*/
public void updateShowingData(View view, Object data) {
notifyFlags.put(view.getId(), data);
}

public Object getShowingData(View view) {
return notifyFlags.get(view.getId());
}
}

adapter代码:添加了增删的方法

package com.smart_holder_lib;

import android.content.Context;
import android.util.Log;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;

/**
* @param <T> T为当前Item数据
* @author Relice
*/
public abstract class LazyAdapter<T> extends BaseAdapter {
private static final String TAG = LazyAdapter.class.getSimpleName();
protected Context mContext;
//设置数据
private final List<T>    dataSet       = new ArrayList<T>();
//被选中要删除的数据
public final HashSet<T> removeDataSet = new HashSet<T>();
// adapter的item布局
private int mItemLayoutId;
//checkBox选中的数据
private T   removeData;
private List<T> datas;//传过来的数据

/**
* 调用该方法你需要传入以下数据
* @param context
* @param datas   列表需要显示的数据集合
* @param mItemLayoutId item布局
*/
public LazyAdapter(Context context, List<T> datas, int mItemLayoutId) {
this.mContext = context;
this.datas = datas;
this.mItemLayoutId = mItemLayoutId;
setDatas(datas);
}

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

@Override
public T getItem(int position) {
if (position > -1 && position < dataSet.size()) {
return dataSet.get(position);
}
return null;
}

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

@Override
public View getView(int position, View convertView, ViewGroup parent) {
T currentData = getItem(position);
//holder处理的事情
//1.处理item的每个点击事件
//2.封装每个item的单一数据
SmartViewHolder<T> viewHolder = SmartViewHolder.obtainHolder(mContext, convertView, currentData, parent, mItemLayoutId, this);
//显示holder填好数据的item --    show UI
showDataInItemView(viewHolder, currentData);
return viewHolder.getConvertView();
}

/**
* 覆盖此方法来显示UI
*
* @param viewHolder  holder ,使用他来操作view的一些逻辑事件
* @param currentData 当前item的数据
*/
protected abstract void showDataInItemView(SmartViewHolder<T> viewHolder, T currentData);

/**
* 覆盖此方法来处理点击事件,如果当前item没有任何点击事件,直接空实现即可
*
* @param convertView item view
* @param view        clicked view
* @param currentData data of current item
*/
protected abstract void handleClick(SmartViewHolder<T> convertView, View view, T currentData);

/**
* 重置所有数据
*/
public void setDatas(List<T> datas) {
if (datas == null) {
return;
}
Log.d(TAG, "setDatas " + datas.size());
this.dataSet.clear();
this.dataSet.addAll(datas);
notifyDataSetChanged();
}

/**
* 重置单个数据
*/
public void setData(T data) {
if (data == null) {
return;
}
dataSet.clear();
dataSet.add(data);
}

/**
* 加载更多时-添加数据
*
* @param datas
* @param filterData
*/
public void addDatas(List<T> datas, boolean filterData) {
if (datas == null) {
return;
}
if (filterData) {
this.dataSet.removeAll(datas);
}
this.dataSet.addAll(datas);
notifyDataSetChanged();
}

/**
* 加载更多时-添加数据
*
* @param datas
*/
public void addDatas(List<T> datas) {
addDatas(datas, false);
}

/**
* 加载更多时-添加数据
*
* @param data
*/
public void addData(T data) {
if (data == null || dataSet.contains(data)) {
return;
}
dataSet.add(data);
notifyDataSetChanged();
}

/**
* 添加要删除的数据--批量添加
*
* @param removeData
*/
public void addRemoveData(T removeData) {
if (removeData != null) {
removeDataSet.add(removeData);
}
}

/**
* 移除被添加的数据
*
* @param removeData
*/
public void removeAddedData(T removeData) {
if (removeData != null) {
removeDataSet.remove(removeData);
}
}

/**
* 批量删除添被加了数据,
* 一般用于activity回调adapter刷新数据
*/
public void removeAllData() {
if (removeDataSet == null) {
return;
}
for (Iterator it = removeDataSet.iterator(); it.hasNext(); ) {
T next = (T) it.next();
if (next == null) {
continue;
}
this.dataSet.remove(next);
this.datas.remove(next);//TODO 删除传过来的数据
it.remove();
}
notifyDataSetChanged();
}
}

Demo使用:
下面只给了主要代码;部分helper,utils 工具类没贴出来

import android.app.Activity;
import android.content.Intent;
import android.text.TextUtils;
import android.view.View;
import android.widget.CheckBox;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.RelativeLayout;
import android.widget.TextView;

import com.smart_holder_lib.LazyAdapter;
import com.smart_holder_lib.SmartViewHolder;

import java.util.List;

/**
* 我的关注-品牌列表
* 优化处理
*
* @author Relice
*/
public class MyXiuNewCollectionBrandAdapter extends LazyAdapter<BrandInfo> {
private Activity activity;
private Utils    util;
private int      index;

public void setIndex(int index) {
this.index = index;
}

public MyXiuNewCollectionBrandAdapter(Activity activity, List<BrandInfo> list, int index, int layoutId) {
super(activity, list, layoutId);
this.activity = activity;
util = Utils.getInstance();
this.index = index;
}

@Override
protected void showDataInItemView(SmartViewHolder<BrandInfo> holder, BrandInfo brandInfo) {
ImageView my_collection_brand_iv = holder.getView(R.id.my_collection_brand_iv, false);
TextView my_collection_brand_tv = holder.getView(R.id.my_collection_brand_tv, false);
TextView my_collection_brandname = holder.getView(R.id.my_collection_brandname, false);
TextView my_collection_brandchosen = holder.getView(R.id.my_collection_brandchosen, false);//精选卖场TV
CheckBox my_collection_delbranditem_cb = holder.getView(R.id.my_collection_delbranditem_cb, true);//勾选删除
RelativeLayout my_collection_right_layouttop = holder.getView(R.id.my_collection_right_layouttop, true);//新品上架
RelativeLayout my_collection_right_layoutbuttom = holder.getView(R.id.my_collection_right_layoutbuttom, true);//精选卖场
LinearLayout collect_brand_logo_layout = holder.getView(R.id.collect_brand_logo_layout, true);//品牌logo卖场
//是否需要删除
my_collection_delbranditem_cb.setChecked(brandInfo.isDelItem());

//品牌图片
final boolean hasImage = !TextUtils.isEmpty(brandInfo.getBrandImg());
if (hasImage) {
//数据显示完成后,用holder记住view正在显示的数据,下次notify时,如果数据没有变化,则不用再次显示
if (holder.showingDataChanged(my_collection_brand_iv, brandInfo.getBrandImg())) {
util.loadBrandCollectImage(activity, my_collection_brand_iv, brandInfo.getBrandImg());
holder.updateShowingData(my_collection_brand_iv, brandInfo.getBrandImg());
SHelper.vis(my_collection_brand_iv);
SHelper.gone(my_collection_brand_tv);
}
} else {//没有图片显示品牌名
SHelper.vis(my_collection_brand_tv);
SHelper.gone(my_collection_brand_iv);
my_collection_brand_tv.setText(brandInfo.getBrandName());
}

//品牌名
String brandName = brandInfo.getBrandName();
if (holder.showingDataChanged(my_collection_brandname, brandName)) {
//            数据显示完成后,用holder记住view正在显示的数据,下次notify时,如果数据没有变化,则不用再次显示
my_collection_brandname.setText(brandName);
holder.updateShowingData(my_collection_brandname, brandName);
} else {
//            SLog.dd("复用数据..");
}

//编辑/完成
if (index == 1) {
SHelper.vis(my_collection_delbranditem_cb);
} else {
SHelper.gone(my_collection_delbranditem_cb);
}

//处理编辑状态点击
handleEdietStatus(my_collection_delbranditem_cb, my_collection_right_layoutbuttom, my_collection_right_layouttop, collect_brand_logo_layout);

//卖场活动是否结束
final int topicCnt = brandInfo.getTopicCnt();
if (topicCnt == 0) {
my_collection_right_layoutbuttom.setEnabled(false);
my_collection_brandchosen.setTextColor(activity.getResources().getColor(R.color.xiu_grey));
} else {
my_collection_brandchosen.setTextColor(activity.getResources().getColor(R.color.xiu_black));
//            my_collection_right_layoutbuttom.setEnabled(true);
}
}

private void handleEdietStatus(CheckBox cb, View... view) {
boolean clickAble = true;
if (cb != null && cb.getVisibility() == View.VISIBLE)
clickAble = false;
else
clickAble = true;

for (int i = 0; i < view.length; i++) {
view[i].setEnabled(clickAble);
}
}

@Override
protected void handleClick(SmartViewHolder<BrandInfo> convertView, View view, BrandInfo brandInfo) {
switch (view.getId()) {
case R.id.my_collection_right_layouttop://新品上架
activity.startActivity(new Intent(activity, BrandGoodsListActivity.class).putExtra("brand_id",
brandInfo.getBrandId() +
"").putExtra("brand_name", brandInfo.getBrandName()).putExtra("brand_img", brandInfo.getBrandImg()).putExtra("brand_tag", 3).putExtra("goodsFrom", "UC0040"));
break;
case R.id.my_collection_right_layoutbuttom://精选卖场
final int topicCnt = brandInfo.getTopicCnt();
if (topicCnt == 1) {
activity.startActivity(new Intent(activity, GoodsListActivity.class).
putExtra("activity_id", brandInfo.getActivityId()).putExtra("activity_name", brandInfo.getBrandName()).putExtra("activity_img", brandInfo.getBrandImg()).
putExtra("goodsFrom", "UC0040"));
} else {
activity.startActivity(new Intent(activity, SelectStoresActivity.class).
putExtra("brand_name", brandInfo.getBrandName()).putExtra("brand_id", brandInfo.getBrandId()).putExtra("goodsFrom", "UC0040"));
}
break;
case R.id.collect_brand_logo_layout: //品牌logo卖场
activity.startActivity(new Intent(activity, BrandGoodsListActivity.class).putExtra("brand_id",
brandInfo.getBrandId() +
"").putExtra("brand_name", brandInfo.getBrandName()).putExtra("brand_img", brandInfo.getBrandImg()).putExtra("goodsFrom", "UC0040"));
break;
case R.id.my_collection_delbranditem_cb: //勾选要删除的品牌

CheckBox cb = (CheckBox) view.findViewById(R.id.my_collection_delbranditem_cb);
boolean checked = cb.isChecked();
if (checked) {
brandInfo.setIsDelItem(true);
addRemoveData(brandInfo);//添加删除
} else {
brandInfo.setIsDelItem(false);
removeAddedData(brandInfo);//取消删除
}
break;
}
}
}