列表视图过滤器Android

Question

列表视图过滤器Android我已经在android中创建了一个列表视图，我希望在列表的上方添加编辑文本，当用户输入文本时，列表将根据用户输入进行筛选。如果有一种方法可以过滤Android中的列表适配器，谁能告诉我吗？

Answer 1

实现适配器可过滤：

public class vJournalAdapter extends ArrayAdapter<JournalModel> implements Filterable{private ArrayList<JournalModel>
 items;private Context mContext;....

然后创建过滤器类：

private class JournalFilter extends Filter{

    @Override
    protected FilterResults performFiltering(CharSequence constraint) {
        FilterResults result = new FilterResults();
        List<JournalModel> allJournals = getAllJournals();
        if(constraint == null || constraint.length() == 0){

            result.values = allJournals;
            result.count = allJournals.size();
        }else{
            ArrayList<JournalModel> filteredList = new ArrayList<JournalModel>();
            for(JournalModel j: allJournals){
                if(j.source.title.contains(constraint))
                    filteredList.add(j);
            }
            result.values = filteredList;
            result.count = filteredList.size();
        }

        return result;
    }
    @SuppressWarnings("unchecked")
    @Override
    protected void publishResults(CharSequence constraint, FilterResults results) {
        if (results.count == 0) {
            notifyDataSetInvalidated();
        } else {
            items = (ArrayList<JournalModel>) results.values;
            notifyDataSetChanged();
        }
    }}

这样，您的适配器是可过滤的，您可以将筛选项传递给适配器的过滤器并完成工作。我希望这会有所帮助。

Answer 2

如果还有人对这个主题感兴趣，我发现筛选列表的最佳方法是创建一个泛型过滤器类，并将其与Java OldSchoolSDK包中包含的一些基本反射/泛型技术一起使用。以下是我所做的：

public class GenericListFilter<T> extends Filter {

    /**
     * Copycat constructor
     * @param list  the original list to be used
     */
    public GenericListFilter (List<T> list, String reflectMethodName, ArrayAdapter<T> adapter) {
        super ();

        mInternalList = new ArrayList<>(list);
        mAdapterUsed  = adapter;

        try {
            ParameterizedType stringListType = (ParameterizedType)
                    getClass().getField("mInternalList").getGenericType();
            mCompairMethod =
                    stringListType.getActualTypeArguments()[0].getClass().getMethod(reflectMethodName);
        }
        catch (Exception ex) {
            Log.w("GenericListFilter", ex.getMessage(), ex);

            try {
                if (mInternalList.size() > 0) {
                    T type = mInternalList.get(0);
                    mCompairMethod = type.getClass().getMethod(reflectMethodName);
                }
            }
            catch (Exception e) {
                Log.e("GenericListFilter", e.getMessage(), e);
            }

        }
    }

    /**
     * Let's filter the data with the given constraint
     * @param constraint
     * @return
     */
    @Override protected FilterResults performFiltering(CharSequence constraint) {
        FilterResults results = new FilterResults();
        List<T> filteredContents = new ArrayList<>();

        if ( constraint.length() > 0 ) {
            try {
                for (T obj : mInternalList) {
                    String result = (String) mCompairMethod.invoke(obj);
                    if (result.toLowerCase().startsWith(constraint.toString().toLowerCase())) {
                        filteredContents.add(obj);
                    }
                }
            }
            catch (Exception ex) {
                Log.e("GenericListFilter", ex.getMessage(), ex);
            }
        }
        else {
            filteredContents.addAll(mInternalList);
        }

        results.values = filteredContents;
        results.count  = filteredContents.size();
        return results;
    }

    /**
     * Publish the filtering adapter list
     * @param constraint
     * @param results
     */
    @Override protected void publishResults(CharSequence constraint, FilterResults results) {
        mAdapterUsed.clear();
        mAdapterUsed.addAll((List<T>) results.values);

        if ( results.count == 0 ) {
            mAdapterUsed.notifyDataSetInvalidated();
        }
        else {
            mAdapterUsed.notifyDataSetChanged();
        }
    }

    // class properties
    private ArrayAdapter<T> mAdapterUsed;
    private List<T> mInternalList;
    private Method  mCompairMethod;}

然后，您需要做的唯一件事是将过滤器创建为一个成员类(可能在视图的“onCreate”中)，传递适配器引用、列表和要调用的过滤方法：

this.mFilter = new GenericFilter<MyObjectBean> (list, "getName", adapter);

现在唯一缺少的是重写适配器类中的“getFilter”方法：

@Override public Filter getFilter () {
     return MyViewClass.this.mFilter;}

全都做完了!你应该成功过滤你的名单-当然，你也应该实现你的过滤算法最好的方式来描述你的需要，下面的代码只是一个例子。..希望能帮上忙保重。