带有本地数据排序和筛选的RecyclerView Adapter

类主体:

/**
 * Created by XQ Yang on 2017-3-8 15:30:05
 * Description : 带有搜索和排序功能的adapter
 */

public abstract class SortFilterRVAdapter<ITEMBEAN extends SortBean> extends BaseRecyclerViewAdapter<ITEMBEAN> implements MyFilterable<ITEMBEAN> {
    private static Comparator<SortBean> sCreateTImeComparator;
    private static Comparator<SortBean> sFollowTimeComparator;
    private static Comparator<SortBean> sCreateTImeComparatorDesc;
    private static Comparator<SortBean> sFollowTimeComparatorDesc;
    protected List<ITEMBEAN> searchCache;
    protected List<ITEMBEAN> sortCache;
    public static final int SORT_CREATE_TIME = 102;
    public static final int SORT_CREATE_TIME_DESC = 103;
    public static final int SORT_LAST_FOLLOW_TIME = 100;
    public static final int SORT_LAST_FOLLOW_TIME_DESC = 101;
    public static final int SORT_RECOVER = -1;
    private Comparator<? super ITEMBEAN> comparator;

    static {
        sCreateTImeComparator = (o1, o2) -> (TextUtils.isEmpty(o1.getCreateTime()) || TextUtils.isEmpty(o2.getCreateTime()) ? 0 : (o1.getCreateTime().compareTo(
            o2.getCreateTime())));
        sFollowTimeComparator = (o1, o2) -> (TextUtils.isEmpty(o1.getFollowupTime()) || TextUtils.isEmpty(o2.getFollowupTime()) ? 0 : (o1.getFollowupTime().compareTo(
            o2.getFollowupTime())));
        sCreateTImeComparatorDesc = (o1, o2) -> (TextUtils.isEmpty(o1.getCreateTime()) || TextUtils.isEmpty(o2.getCreateTime()) ? 0 : (o2.getCreateTime().compareTo(
            o1.getCreateTime())));
        sFollowTimeComparatorDesc = (o1, o2) -> (TextUtils.isEmpty(o1.getFollowupTime()) || TextUtils.isEmpty(o2.getFollowupTime()) ? 0 : (o2.getFollowupTime().compareTo(
            o1.getFollowupTime())));
    }

    @IntDef( { SORT_CREATE_TIME, SORT_CREATE_TIME_DESC, SORT_LAST_FOLLOW_TIME, SORT_LAST_FOLLOW_TIME_DESC, SORT_RECOVER })
    @Retention(RetentionPolicy.SOURCE)
    public @interface SortType {
    }

    public SortFilterRVAdapter(Activity context, List<ITEMBEAN> list) {
        super(context, list);
        searchCache = new ArrayList<>();
        searchCache.addAll(list);
    }

    public SortFilterRVAdapter(Activity context) {
        super(context);
        comparator = sCreateTImeComparator;
        searchCache = new ArrayList<>();
    }

    /**
     * 替换数据和搜索的缓存 新建adapter数据为空  后获取到数据时使用
     */
    public void addDataAndCache(List<ITEMBEAN> list) {
        replaceDatas(list);
        searchCache.clear();
        searchCache.addAll(list);
    }

    @Override
    public void replaceDatas(List<ITEMBEAN> datas) {
        if (searchCache != null) {
            searchCache.clear();
        }
        super.replaceDatas(datas);
    }

    @Override
    public void addDatas(List<ITEMBEAN> datas) {
        mAdapterListData.addAll(datas);
        if (searchCache == null) {
            searchCache = new ArrayList<>();
        }
        searchCache.addAll(datas);
        notifyDataSetChanged();
    }

    @Override
    public Filter getFilter() {
        return new Filter() {
            @Override
            protected FilterResults performFiltering(CharSequence constraint) {
                //初始化过滤结果对象
                FilterResults results = new FilterResults();
                final ArrayList<ITEMBEAN> newValues = new ArrayList<ITEMBEAN>();
                //关键字为空的时候，搜索结果为复制的结果
                if (constraint == null || constraint.length() == 0) {
                    results.count = 0;
                } else {
                    String prefixString = constraint.toString();
                    final int count = searchCache.size();
                    //用于存放暂时的过滤结果
                    for (int i = 0; i < count; i++) {
                        final ITEMBEAN value = searchCache.get(i);
                        if (filterValue(value, prefixString)) {
                            newValues.add(value);
                        }
                    }
                    results.count = newValues.size();
                }
                results.values = newValues;
                return results;//过滤结果
            }

            @Override
            protected void publishResults(CharSequence constraint, FilterResults results) {
                showSearchResult((List<ITEMBEAN>) results.values);
            }
        };
    }

    /**
     * 是否添加到结果中?
     *
     * @return true 添加
     */
    protected abstract boolean filterValue(ITEMBEAN value, String prefixString);

    /**
     * 显示搜索结果
     *
     * @param values 传null的话显示本来的数据(整个列表)
     */
    public void showSearchResult(List<ITEMBEAN> values) {
        mAdapterListData.clear();
        if (values == null) {
            mAdapterListData.addAll(searchCache);
        } else {
            mAdapterListData.addAll(values);
        }
        notifyDataSetChanged();
    }

    /**
     * 进行排序
     */
    public void sort(@SortType int type) {
        if (sortCache == null) {
            sortCache = new ArrayList<>();
            sortCache.addAll(mAdapterListData);
        }
        if (type == SORT_RECOVER) {
            mAdapterListData.addAll(sortCache);
            notifyDataSetChanged();
            return;
        }
        if (sortCache.size() != mAdapterListData.size()) {
            sortCache.clear();
            sortCache.addAll(mAdapterListData);
        }
        switch (type) {
            case SORT_CREATE_TIME:
                comparator = sCreateTImeComparator;
                break;
            case SORT_CREATE_TIME_DESC:
                comparator = sCreateTImeComparatorDesc;
                break;
            case SORT_LAST_FOLLOW_TIME_DESC:
                comparator = sFollowTimeComparatorDesc;
                break;
            default://SORT_LAST_FOLLOW_TIME 默认此序
                comparator = sFollowTimeComparator;
                break;
        }
        Collections.sort(mAdapterListData, comparator);
        //for (int i = 0; i < mAdapterListData.size(); i++) {
        //    System.out.println(mAdapterListData.get(i).getCreateTime() + "    :  " + sortCache.get(i).getCreateTime());
        //}
        notifyDataSetChanged();
    }
}

辅助接口:

public interface MyFilterable <ITEMBEAN>extends Filterable {
    void showSearchResult(List<ITEMBEAN> values);
}

public interface SortBean {
    String getCreateTime();

    String getFollowupTime();
}