介绍

由于您的问题并不清楚您到底遇到了什么问题，因此我写了这个关于如何实现此功能的快速演练；如果您仍有疑问，请随时提出。

我在这个GitHub 存储库中有一个关于我在这里谈论的所有内容的工作示例。

无论如何，结果应该是这样的：

如果您首先想使用演示应用程序，您可以从 Play 商店安装它：

无论如何，让我们开始吧。

设置SearchView

在文件夹中res/menu创建一个名为main_menu.xml. 在其中添加一个项目并将其设置actionViewClass为android.support.v7.widget.SearchView. 由于您使用的是支持库，因此您必须使用支持库的命名空间来设置actionViewClass属性。您的 xml 文件应如下所示：

<menu xmlns:android="http://schemas.android.com/apk/res/android"
      xmlns:app="http://schemas.android.com/apk/res-auto">

    <item android:id="@+id/action_search"
          android:title="@string/action_search"
          app:actionViewClass="android.support.v7.widget.SearchView"
          app:showAsAction="always"/>

</menu>

在您Fragment或Activity您必须像往常一样扩展此菜单 xml，然后您可以查找MenuItem其中包含 的SearchView并实现OnQueryTextListener我们将使用的来侦听对输入的文本的更改SearchView：

@Override
public boolean onCreateOptionsMenu(Menu menu) {
    getMenuInflater().inflate(R.menu.menu_main, menu);

    final MenuItem searchItem = menu.findItem(R.id.action_search);
    final SearchView searchView = (SearchView) searchItem.getActionView();
    searchView.setOnQueryTextListener(this);

    return true;
}

@Override
public boolean onQueryTextChange(String query) {
    // Here is where we are going to implement the filter logic
    return false;
}

@Override
public boolean onQueryTextSubmit(String query) {
    return false;
}

现在SearchView可以使用了。一旦onQueryTextChange()我们完成了Adapter.

设置Adapter

首先，这是我将用于此示例的模型类：

public class ExampleModel {

    private final long mId;
    private final String mText;

    public ExampleModel(long id, String text) {
        mId = id;
        mText = text;
    }

    public long getId() {
        return mId;
    }

    public String getText() {
        return mText;
    }
}

这只是您的基本模型，它将在RecyclerView. 这是我将用来显示文本的布局：

<?xml version="1.0" encoding="utf-8"?>
<layout xmlns:android="http://schemas.android.com/apk/res/android">

    <data>

        <variable
            name="model"
            type="com.github.wrdlbrnft.searchablerecyclerviewdemo.ui.models.ExampleModel"/>

    </data>

    <FrameLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:background="?attr/selectableItemBackground"
        android:clickable="true">

        <TextView
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:padding="8dp"
            android:text="@{model.text}"/>

    </FrameLayout>

</layout>

如您所见，我使用数据绑定。如果您以前从未使用过数据绑定，请不要气馁！它非常简单和强大，但是我无法解释它在这个答案的范围内是如何工作的。

这是ViewHolder班级的ExampleModel：

public class ExampleViewHolder extends RecyclerView.ViewHolder {

    private final ItemExampleBinding mBinding;

    public ExampleViewHolder(ItemExampleBinding binding) {
        super(binding.getRoot());
        mBinding = binding;
    }

    public void bind(ExampleModel item) {
        mBinding.setModel(item);
    }
}

再次没什么特别的。它只是使用数据绑定将模型类绑定到这个布局，正如我们在上面的布局 xml 中定义的那样。

现在我们终于可以来到真正有趣的部分：编写适配器。我将跳过 的基本实现，Adapter而是专注于与此答案相关的部分。

但首先我们要谈一件事：SortedList班级。

排序列表

这SortedList是一个非常棒的工具，它是RecyclerView库的一部分。它负责通知Adapter数据集的更改，这是一种非常有效的方式。它唯一需要您做的就是指定元素的顺序。您需要通过实现一个compare()方法来比较 a 中的两个元素来做到这SortedList一点Comparator。但它不是对 aList进行排序，而是用于对RecyclerView!中的项目进行排序。

通过您必须实现的类SortedList与 交互：Adapter``Callback

private final SortedList.Callback<ExampleModel> mCallback = new SortedList.Callback<ExampleModel>() {

    @Override
    public void onInserted(int position, int count) {
         mAdapter.notifyItemRangeInserted(position, count);
    }

    @Override
    public void onRemoved(int position, int count) {
        mAdapter.notifyItemRangeRemoved(position, count);
    }

    @Override
    public void onMoved(int fromPosition, int toPosition) {
        mAdapter.notifyItemMoved(fromPosition, toPosition);
    }

    @Override
    public void onChanged(int position, int count) {
        mAdapter.notifyItemRangeChanged(position, count);
    }

    @Override
    public int compare(ExampleModel a, ExampleModel b) {
        return mComparator.compare(a, b);
    }

    @Override
    public boolean areContentsTheSame(ExampleModel oldItem, ExampleModel newItem) {
        return oldItem.equals(newItem);
    }

    @Override
    public boolean areItemsTheSame(ExampleModel item1, ExampleModel item2) {
        return item1.getId() == item2.getId();
    }
}

在回调顶部的方法中，如onMoved,onInserted等，您必须调用等效的 notify 方法Adapter。底部的三个方法，compare你必须根据你想要显示什么样的对象以及这些对象应该以什么顺序出现在屏幕上来实现。areContentsTheSame``areItemsTheSame

让我们一一介绍这些方法：

@Override
public int compare(ExampleModel a, ExampleModel b) {
    return mComparator.compare(a, b);
}

这是compare()我前面讲的方法。在此示例中，我只是将调用传递给Comparator比较两个模型的 a。如果您希望项目按字母顺序显示在屏幕上。此比较器可能如下所示：

private static final Comparator<ExampleModel> ALPHABETICAL_COMPARATOR = new Comparator<ExampleModel>() {
    @Override
    public int compare(ExampleModel a, ExampleModel b) {
        return a.getText().compareTo(b.getText());
    }
};

现在让我们看看下一个方法：

@Override
public boolean areContentsTheSame(ExampleModel oldItem, ExampleModel newItem) {
    return oldItem.equals(newItem);
}

此方法的目的是确定模型的内容是否已更改。使用SortedList它来确定是否需要调用更改事件 - 换句话说，是否RecyclerView应该交叉淡入淡出旧版本和新版本。如果你的模型类有一个正确的equals()实现hashCode()，你通常可以像上面那样实现它。如果我们在类中添加一个equals()andhashCode()实现，ExampleModel它应该看起来像这样：

public class ExampleModel implements SortedListAdapter.ViewModel {

    private final long mId;
    private final String mText;

    public ExampleModel(long id, String text) {
        mId = id;
        mText = text;
    }

    public long getId() {
        return mId;
    }

    public String getText() {
        return mText;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        ExampleModel model = (ExampleModel) o;

        if (mId != model.mId) return false;
        return mText != null ? mText.equals(model.mText) : model.mText == null;

    }

    @Override
    public int hashCode() {
        int result = (int) (mId ^ (mId >>> 32));
        result = 31 * result + (mText != null ? mText.hashCode() : 0);
        return result;
    }
}

快速旁注：大多数 IDE，如 Android Studio、IntelliJ 和 Eclipse 都具有为您生成equals()和hashCode()实现的功能，只需按一下按钮！所以你不必自己实现它们。在互联网上查找它在您的 IDE 中的工作原理！

现在让我们看一下最后一种方法：

@Override
public boolean areItemsTheSame(ExampleModel item1, ExampleModel item2) {
    return item1.getId() == item2.getId();
}

使用SortedList此方法检查两个项目是否引用同一事物。简单来说（不解释其SortedList工作原理），它用于确定对象是否已包含在 中，List以及是否需要播放添加、移动或更改动画。如果您的模型有 id，您通常会在此方法中只比较 id。如果他们不这样做，您需要找出其他方法来检查这一点，但是您最终实现这取决于您的特定应用程序。通常，给所有模型一个 id 是最简单的选择 - 例如，如果您从数据库中查询数据，它可能是主键字段。

通过SortedList.Callback正确实现，我们可以创建一个实例SortedList：

final SortedList<ExampleModel> list = new SortedList<>(ExampleModel.class, mCallback);

作为构造函数中的第一个参数，SortedList您需要传递模型的类。另一个参数就是SortedList.Callback我们上面定义的。

现在让我们开始做正事：如果我们Adapter用 a实现SortedList它应该看起来像这样：

public class ExampleAdapter extends RecyclerView.Adapter<ExampleViewHolder> {

    private final SortedList<ExampleModel> mSortedList = new SortedList<>(ExampleModel.class, new SortedList.Callback<ExampleModel>() {
        @Override
        public int compare(ExampleModel a, ExampleModel b) {
            return mComparator.compare(a, b);
        }

        @Override
        public void onInserted(int position, int count) {
            notifyItemRangeInserted(position, count);
        }

        @Override
        public void onRemoved(int position, int count) {
            notifyItemRangeRemoved(position, count);
        }

        @Override
        public void onMoved(int fromPosition, int toPosition) {
            notifyItemMoved(fromPosition, toPosition);
        }

        @Override
        public void onChanged(int position, int count) {
            notifyItemRangeChanged(position, count);
        }

        @Override
        public boolean areContentsTheSame(ExampleModel oldItem, ExampleModel newItem) {
            return oldItem.equals(newItem);
        }

        @Override
        public boolean areItemsTheSame(ExampleModel item1, ExampleModel item2) {
            return item1.getId() == item2.getId();
        }
    });

    private final LayoutInflater mInflater;
    private final Comparator<ExampleModel> mComparator;

    public ExampleAdapter(Context context, Comparator<ExampleModel> comparator) {
        mInflater = LayoutInflater.from(context);
        mComparator = comparator;
    }

    @Override
    public ExampleViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
        final ItemExampleBinding binding = ItemExampleBinding.inflate(inflater, parent, false);
        return new ExampleViewHolder(binding);
    }

    @Override
    public void onBindViewHolder(ExampleViewHolder holder, int position) {
        final ExampleModel model = mSortedList.get(position);
        holder.bind(model);
    }

    @Override
    public int getItemCount() {
        return mSortedList.size();
    }
}

用于对项目进行排序的Comparator是通过构造函数传入的，因此Adapter即使项目应该以不同的顺序显示，我们也可以使用相同的。

现在我们几乎完成了！但我们首先需要一种向Adapter. 为此，我们可以向 中添加方法Adapter，允许我们向 中添加和删除项目SortedList：

public void add(ExampleModel model) {
    mSortedList.add(model);
}

public void remove(ExampleModel model) {
    mSortedList.remove(model);
}

public void add(List<ExampleModel> models) {
    mSortedList.addAll(models);
}

public void remove(List<ExampleModel> models) {
    mSortedList.beginBatchedUpdates();
    for (ExampleModel model : models) {
        mSortedList.remove(model);
    }
    mSortedList.endBatchedUpdates();
}

我们不需要在这里调用任何通知方法，因为SortedList已经通过SortedList.Callback! 除此之外，这些方法的实现非常简单，只有一个例外：删除List模型的 remove 方法。由于SortedList只有一个 remove 方法可以删除单个对象，因此我们需要遍历列表并逐个删除模型。在开始时调用beginBatchedUpdates()批处理我们将对一起进行的所有更改SortedList并提高性能。当我们调用时endBatchedUpdates()，RecyclerView会立即通知所有更改。

此外，您必须了解的是，如果您将对象添加到SortedList并且它已经在其中SortedList，则不会再次添加它。相反，SortedList它使用该areContentsTheSame()方法来确定对象是否已更改 - 以及它是否包含RecyclerView将更新的项目。

无论如何，我通常更喜欢的是一种允许我RecyclerView一次替换所有项目的方法。删除不在的所有内容List并添加所有缺少的项目SortedList：

public void replaceAll(List<ExampleModel> models) {
    mSortedList.beginBatchedUpdates();
    for (int i = mSortedList.size() - 1; i >= 0; i--) {
        final ExampleModel model = mSortedList.get(i);
        if (!models.contains(model)) {
            mSortedList.remove(model);
        }
    }
    mSortedList.addAll(models);
    mSortedList.endBatchedUpdates();
}

此方法再次将所有更新批处理在一起以提高性能。第一个循环是相反的，因为在开始时删除一个项目会弄乱它之后出现的所有项目的索引，这在某些情况下会导致数据不一致等问题。之后，我们只需将 the 添加List到SortedListusingaddAll()以添加尚未在其中的所有项目，SortedList并且 - 就像我上面描述的那样 - 更新已经在其中SortedList但已更改的所有项目。

这样Adapter就完成了。整个事情应该是这样的：

public class ExampleAdapter extends RecyclerView.Adapter<ExampleViewHolder> {

    private final SortedList<ExampleModel> mSortedList = new SortedList<>(ExampleModel.class, new SortedList.Callback<ExampleModel>() {
        @Override
        public int compare(ExampleModel a, ExampleModel b) {
            return mComparator.compare(a, b);
        }

        @Override
        public void onInserted(int position, int count) {
            notifyItemRangeInserted(position, count);
        }

        @Override
        public void onRemoved(int position, int count) {
            notifyItemRangeRemoved(position, count);
        }

        @Override
        public void onMoved(int fromPosition, int toPosition) {
            notifyItemMoved(fromPosition, toPosition);
        }

        @Override
        public void onChanged(int position, int count) {
            notifyItemRangeChanged(position, count);
        }

        @Override
        public boolean areContentsTheSame(ExampleModel oldItem, ExampleModel newItem) {
            return oldItem.equals(newItem);
        }

        @Override
        public boolean areItemsTheSame(ExampleModel item1, ExampleModel item2) {
            return item1 == item2;
        }
    });

    private final Comparator<ExampleModel> mComparator;
    private final LayoutInflater mInflater;

    public ExampleAdapter(Context context, Comparator<ExampleModel> comparator) {
        mInflater = LayoutInflater.from(context);
        mComparator = comparator;
    }

    @Override
    public ExampleViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
        final ItemExampleBinding binding = ItemExampleBinding.inflate(mInflater, parent, false);
        return new ExampleViewHolder(binding);
    }

    @Override
    public void onBindViewHolder(ExampleViewHolder holder, int position) {
        final ExampleModel model = mSortedList.get(position);
        holder.bind(model);
    }

    public void add(ExampleModel model) {
        mSortedList.add(model);
    }

    public void remove(ExampleModel model) {
        mSortedList.remove(model);
    }

    public void add(List<ExampleModel> models) {
        mSortedList.addAll(models);
    }

    public void remove(List<ExampleModel> models) {
        mSortedList.beginBatchedUpdates();
        for (ExampleModel model : models) {
            mSortedList.remove(model);
        }
        mSortedList.endBatchedUpdates();
    }

    public void replaceAll(List<ExampleModel> models) {
        mSortedList.beginBatchedUpdates();
        for (int i = mSortedList.size() - 1; i >= 0; i--) {
            final ExampleModel model = mSortedList.get(i);
            if (!models.contains(model)) {
                mSortedList.remove(model);
            }
        }
        mSortedList.addAll(models);
        mSortedList.endBatchedUpdates();
    }

    @Override
    public int getItemCount() {
        return mSortedList.size();
    }
}

现在唯一缺少的是实现过滤！

实现过滤器逻辑

要实现过滤器逻辑，我们首先必须定义List所有可能的模型。对于这个例子，我从一系列电影中创建了一个List实例：ExampleModel

private static final String[] MOVIES = new String[]{
        ...
};

private static final Comparator<ExampleModel> ALPHABETICAL_COMPARATOR = new Comparator<ExampleModel>() {
    @Override
    public int compare(ExampleModel a, ExampleModel b) {
        return a.getText().compareTo(b.getText());
    }
};

private ExampleAdapter mAdapter;
private List<ExampleModel> mModels;
private RecyclerView mRecyclerView;

    @Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    mBinding = DataBindingUtil.setContentView(this, R.layout.activity_main);

    mAdapter = new ExampleAdapter(this, ALPHABETICAL_COMPARATOR);

    mBinding.recyclerView.setLayoutManager(new LinearLayoutManager(this));
    mBinding.recyclerView.setAdapter(mAdapter);

    mModels = new ArrayList<>();
    for (String movie : MOVIES) {
        mModels.add(new ExampleModel(movie));
    }
    mAdapter.add(mModels);
}

这里没有什么特别的，我们只是实例化Adapter并将其设置为RecyclerView. 之后，我们从数组List中的电影名称创建一个模型。MOVIES然后我们将所有模型添加到SortedList.

现在我们可以回到onQueryTextChange()我们之前定义的地方并开始实现过滤器逻辑：

@Override
public boolean onQueryTextChange(String query) {
    final List<ExampleModel> filteredModelList = filter(mModels, query);
    mAdapter.replaceAll(filteredModelList);
    mBinding.recyclerView.scrollToPosition(0);
    return true;
}

这又很简单。我们调用该方法filter()并传入Listof ExampleModels 以及查询字符串。然后我们调用replaceAll()并Adapter传入由 .List返回的过滤器filter()。我们还必须调用scrollToPosition(0)以RecyclerView确保用户在搜索某些内容时始终可以看到所有项目。否则RecyclerView，过滤时可能会停留在向下滚动的位置，随后会隐藏一些项目。滚动到顶部可确保在搜索时获得更好的用户体验。

现在唯一要做的就是实现filter()自己：

private static List<ExampleModel> filter(List<ExampleModel> models, String query) {
    final String lowerCaseQuery = query.toLowerCase();

    final List<ExampleModel> filteredModelList = new ArrayList<>();
    for (ExampleModel model : models) {
        final String text = model.getText().toLowerCase();
        if (text.contains(lowerCaseQuery)) {
            filteredModelList.add(model);
        }
    }
    return filteredModelList;
}

我们在这里做的第一件事是调用toLowerCase()查询字符串。我们不希望我们的搜索函数区分大小写，通过调用toLowerCase()我们比较的所有字符串，我们可以确保无论大小写如何都返回相同的结果。然后它只是遍历List我们传递给它的所有模型，并检查查询字符串是否包含在模型的文本中。如果是，则将模型添加到过滤后的List.

就是这样！上面的代码将在 API 级别 7 及更高版本上运行，从 API 级别 11 开始，您可以免费获得项目动画！

我意识到这是一个非常详细的描述，它可能使整个事情看起来比实际更复杂，但是有一种方法可以概括整个问题并使Adapter基于一个SortedList更简单的实现。

泛化问题并简化适配器

在本节中，我不会详细介绍 - 部分原因是我在 Stack Overflow 上遇到了字符数限制，但也因为上面已经解释了大部分内容 - 但总结一下变化：我们可以实现一个基Adapter类它已经负责处理SortedList模型以及将模型绑定到ViewHolder实例，并提供了一种Adapter基于SortedList. 为此，我们必须做两件事：

• 我们需要创建一个ViewModel所有模型类都必须实现的接口
• 我们需要创建一个ViewHolder子类，它定义了一个可以用来自动绑定模型的bind()方法。Adapter

RecyclerView这使我们只需实现模型和相应的实现，就可以专注于应该在其中显示的内容ViewHolder。使用这个基类，我们不必担心Adapter和它的复杂细节SortedList。

排序列表适配器

由于 StackOverflow 上答案的字符限制，我无法完成实现此基类的每个步骤，甚至无法在此处添加完整的源代码，但您可以在此找到此基类的完整源代码 - 我SortedListAdapter称之为GitHub 要点。

为了让您的生活更简单，我在 jCenter 上发布了一个库，其中包含SortedListAdapter! 如果您想使用它，那么您需要做的就是将此依赖项添加到您的应用程序的 build.gradle 文件中：

compile 'com.github.wrdlbrnft:sorted-list-adapter:0.2.0.1'

您可以在图书馆主页上找到有关该图书馆的更多信息。

使用 SortedListAdapter

要使用 ，SortedListAdapter我们必须进行两项更改：

• 更改 以ViewHolder使其扩展SortedListAdapter.ViewHolder。类型参数应该是应该绑定到 this 的模型ViewHolder——在这种情况下ExampleModel。您必须将数据绑定到模型performBind()而不是bind().

```scala
public class ExampleViewHolder extends SortedListAdapter.ViewHolder {

   private final ItemExampleBinding mBinding;

   public ExampleViewHolder(ItemExampleBinding binding) {
       super(binding.getRoot());
       mBinding = binding;
   }

   @Override
   protected void performBind(ExampleModel item) {
       mBinding.setModel(item);
   }

}
```

• 确保所有模型都实现了ViewModel接口：

java public class ExampleModel implements SortedListAdapter.ViewModel { ... }

之后，我们只需更新ExampleAdapter以扩展SortedListAdapter和删除我们不再需要的所有内容。type 参数应该是您正在使用的模型的类型——在这种情况下ExampleModel。但是，如果您使用不同类型的模型，则将 type 参数设置为ViewModel.

public class ExampleAdapter extends SortedListAdapter<ExampleModel> {

    public ExampleAdapter(Context context, Comparator<ExampleModel> comparator) {
        super(context, ExampleModel.class, comparator);
    }

    @Override
    protected ViewHolder<? extends ExampleModel> onCreateViewHolder(LayoutInflater inflater, ViewGroup parent, int viewType) {
        final ItemExampleBinding binding = ItemExampleBinding.inflate(inflater, parent, false);
        return new ExampleViewHolder(binding);
    }

    @Override
    protected boolean areItemsTheSame(ExampleModel item1, ExampleModel item2) {
        return item1.getId() == item2.getId();
    }

    @Override
    protected boolean areItemContentsTheSame(ExampleModel oldItem, ExampleModel newItem) {
        return oldItem.equals(newItem);
    }
}

之后我们就完成了！然而最后一件事要提： TheSortedListAdapter没有我们原来的相同add()或remove()方法。它使用一个单独的对象来修改列表中可以通过该方法访问的项目。因此，如果要删除或添加必须调用的项目，然后在此实例上添加和删除项目，完成后，调用它以将更改应用于：replaceAll()``ExampleAdapter``Editor``edit()``edit()``Editor``commit()``SortedList

mAdapter.edit()
        .remove(modelToRemove)
        .add(listOfModelsToAdd)
        .commit();

您以这种方式进行的所有更改都被批量处理以提高性能。我们在上面章节中实现的replaceAll()方法也存在于这个Editor对象上：

mAdapter.edit()
        .replaceAll(mModels)
        .commit();

如果您忘记打电话commit()，那么您的任何更改都不会应用！