最后让我们看看 applyAndAnimateMovedItems（）：

 私人无效applyAndAnimateMovedItems（名单＆LT; ExampleModel＆GT; newModels）{
    对于（INT toPosition = newModels.size（） -  1; toPosition＆GT; = 0; toPosition--）{
        最终ExampleModel模型= newModels.get（toPosition）;
        最终诠释fromPosition = mModels.indexOf（模型）;
        如果（fromPosition＆GT; = 0＆安培;＆安培; fromPosition = toPosition！）{
            移动选项（fromPosition，toPosition）;
        }
    }
}
 

此方法实现超过previous两个更复杂的逻辑。它本质上是 applyAndAnimateRemovals的组合（）和 applyAndAnimateAdditions（），但与一捻。你必须认识到，在这一点上 applyAndAnimateRemovals（）和 applyAndAnimateAdditions（）已被调用。所以，我们取消所有需要被删除的项目，我们加入需要被添加的所有新项目。因此，内部列表的适配器和过滤列表包含完全相同的项目，但它们可以以不同的顺序。什么 applyAndAnimateMovedItems（）现在所做的就是通过过滤列表向后遍历和查找每个项目中的索引内部列表。如果它检测到它调用的指数差移动选项（）带来的内部列表的适配器符合过滤的列表。

和与我们的适配器已完成。它现在可以显示的项目，并自动触发相应的动画，我们筛选对象的列表。唯一缺少的，现在是连接搜索查看到 RecyclerView ！

有一件事我还是应该提到的是，虽然这是一个非常简单的方法，以动画它是迄今为止并不是最有效的一个项目。但对于大多数使用情况下，它应该足够越来越一旦你了解它的要点可以非常快速地实现它。

4）实施过滤逻辑

在你的问题引起了我的眼睛一件事是，你保持你想在适配器直接显示的项目列表。而适配器当然必须有一个列表项目内部，你不应该完全保持列表在那里。该适配器 - 顾名思义 - 应该只是把对象到浏览。你给它一个列表的对象和 RecyclerView 变一个查看重presenting每个对象。什么适配器绝对是不负责的创建者对象。

要实现，我们首先要确定所有可能的对象 A 列表过滤逻辑。正如我上面提到的，我们会做的不是适配器内部，但外面的片段或活动包含 RecyclerView 。基本实现（在我的情况下，为片段）看起来是这样的：

 私人RecyclerView mRecyclerView;
私人ExampleAdapter mAdapter;
私人列表＆LT; ExampleModel＆GT; mModels;

@覆盖
公共查看onCreateView（LayoutInflater充气，容器的ViewGroup，捆绑savedInstanceState）{
    最终的视图中查看= inflater.inflate（R.layout.fragment_main，集装箱，假）;

    mRecyclerView =（RecyclerView）view.findViewById（R.id.recyclerView）;

    返回查看;
}

@覆盖
公共无效onViewCreated（查看视图，捆绑savedInstanceState）{
    super.onViewCreated（查看，savedInstanceState）;
    setHasOptionsMenu（真正的）;

    mRecyclerView.setLayoutManager（新LinearLayoutManager（getActivity（）））;

    mModels =新的ArrayList＆LT;＆GT;（）;

    对于（字符串电影：电影）{
        mModels.add（新ExampleModel（电影））;
    }

    mAdapter =新ExampleAdapter（getActivity（），mModels）;
    mRecyclerView.setAdapter（mAdapter）;
}
 

再没有什么特别的。我们设置 RecyclerView 和实例化适配器。我们创建了一个列表项的并存储在一个领域。这份名单将是我们的参考。它包含我们将过滤与搜索查看所有可能的项目。在上面的例子中电影是的String [] 我定义它包含我的测试数据。

现在，我们可以回去 onQueryTextChange（）我们前面，并开始实施过滤逻辑定义的：

  @覆盖
公共布尔onQueryTextChange（查询字符串）{
    最后的名单，其中，ExampleModel＆GT; filteredModelList =过滤器（mModels，查询）;
    mAdapter.animateTo（filteredModelList）;
    mRecyclerView.scrollToPosition（0）;
    返回true;
}
 

这是一次pretty的直线前进。我们调用方法过滤器（），并通过在我们的对象引用列表和查询字符串。然后，我们称之为 animateTo（）在适配器，并通过过滤列表按过滤器（）。我们也有叫 scrollToPosition（0）在 RecyclerView ，以确保用户总能看到所有的项目进行搜索时，的东西。否则， RecyclerView 可能停留在滚动向下的位置，同时过滤并随后隐藏几个项目。滚动顶端确保了更好的用户体验，同时搜索。

唯一剩下现在要做的是落实过滤器（）本身：

 私人列表＆LT; ExampleModel＆GT;过滤器（表＆LT; ExampleModel＆GT;模型，查询字符串）{
    查询= query.toLowerCase（）;

    最后的名单，其中，ExampleModel＆GT; filteredModelList =新的ArrayList＆LT;＆GT;（）;
    对于（ExampleModel型号：型号）{
        最后字符串文本= model.getText（）与toLowerCase（）。
        如果（text.contains（查询））{
            filteredModelList.add（模型）;
        }
    }
    返回filteredModelList;
}
 

我们在这里做的第一件事是调用与toLowerCase（）的查询字符串。我们不希望我们的搜索功能是区分大小写的，通过调用与toLowerCase（）在所有我们比较我们可以确保我们返回的情况下相同的结果而不管。字符串< BR> 过滤器（）通过所有的车型基本上只是迭代的列表我们传递给它并检查查询字符串包含在该模型的文本。如果它是那么的模型将被添加到过滤列表。

这是pretty的太多了！如果你运行你的应用程序，现在你应该可以在 RecyclerView 与搜索查看过滤数据，这整个事情运行在升级Froyo（And​​roid 2.2系统，API 7级）及以上！并开始蜂巢（Android的3.0，API级别11）的所有更改在 RecyclerView 将自动动画显示的数据集！ 我知道这是一个很详细的说明这可能使得这整个事情看起来更加复杂，比它确实是。我建议你​​看一下在 GitHub的信息库的工作示例我上面的话挂您无法理解这件事的一个具体方面。

I am trying to implement the SearchView from the support library. I want the user to be to use the SearchView to filter a List of movies in a RecyclerView.

I have followed a few tutorials so far and I have added the SearchView to the ActionBar, but I am not really sure where to go from here. I have seen a few examples but none of them show results as you start typing.

This is my MainActivity:

public class MainActivity extends ActionBarActivity {

    RecyclerView mRecyclerView;
    RecyclerView.LayoutManager mLayoutManager;
    RecyclerView.Adapter mAdapter;

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

        mRecyclerView = (RecyclerView) findViewById(R.id.recycler_view);
        mRecyclerView.setHasFixedSize(true);

        mLayoutManager = new LinearLayoutManager(this);
        mRecyclerView.setLayoutManager(mLayoutManager);

        mAdapter = new CardAdapter() {
            @Override
            public Filter getFilter() {
                return null;
            }
        };
        mRecyclerView.setAdapter(mAdapter);
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.menu_main, menu);
        SearchManager searchManager = (SearchManager) getSystemService(Context.SEARCH_SERVICE);
        SearchView searchView = (SearchView) menu.findItem(R.id.menu_search).getActionView();
        searchView.setSearchableInfo(searchManager.getSearchableInfo(getComponentName()));
        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        // Handle action bar item clicks here. The action bar will
        // automatically handle clicks on the Home/Up button, so long
        // as you specify a parent activity in AndroidManifest.xml.
        int id = item.getItemId();

        //noinspection SimplifiableIfStatement
        if (id == R.id.action_settings) {
            return true;
        }

        return super.onOptionsItemSelected(item);
    }
}

And this is my Adapter:

public abstract class CardAdapter extends RecyclerView.Adapter<CardAdapter.ViewHolder> implements Filterable {

    List<Movie> mItems;

    public CardAdapter() {
        super();
        mItems = new ArrayList<Movie>();
        Movie movie = new Movie();
        movie.setName("Spiderman");
        movie.setRating("92");
        mItems.add(movie);

        movie = new Movie();
        movie.setName("Doom 3");
        movie.setRating("91");
        mItems.add(movie);

        movie = new Movie();
        movie.setName("Transformers");
        movie.setRating("88");
        mItems.add(movie);

        movie = new Movie();
        movie.setName("Transformers 2");
        movie.setRating("87");
        mItems.add(movie);

        movie = new Movie();
        movie.setName("Transformers 3");
        movie.setRating("86");
        mItems.add(movie);

        movie = new Movie();
        movie.setName("Noah");
        movie.setRating("86");
        mItems.add(movie);

        movie = new Movie();
        movie.setName("Ironman");
        movie.setRating("86");
        mItems.add(movie);

        movie = new Movie();
        movie.setName("Ironman 2");
        movie.setRating("86");
        mItems.add(movie);

        movie = new Movie();
        movie.setName("Ironman 3");
        movie.setRating("86");
        mItems.add(movie);
    }

    @Override
    public ViewHolder onCreateViewHolder(ViewGroup viewGroup, int i) {
        View v = LayoutInflater.from(viewGroup.getContext()).inflate(R.layout.recycler_view_card_item, viewGroup, false);
        return new ViewHolder(v);
    }

    @Override
    public void onBindViewHolder(ViewHolder viewHolder, int i) {
        Movie movie = mItems.get(i);
        viewHolder.tvMovie.setText(movie.getName());
        viewHolder.tvMovieRating.setText(movie.getRating());
    }

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

    class ViewHolder extends RecyclerView.ViewHolder{

        public TextView tvMovie;
        public TextView tvMovieRating;

        public ViewHolder(View itemView) {
            super(itemView);
            tvMovie = (TextView)itemView.findViewById(R.id.movieName);
            tvMovieRating = (TextView)itemView.findViewById(R.id.movieRating);
        }
    }
}

Introduction

Since it is not really clear form your question with what exactly you are having trouble I wrote up this quick walkthrough about how to implement this feature, if you still have questions feel free to ask. I have a working example of everything I am talking about here in this GitHub Repository.

The result should looks something like this:

1) Setting up the SearchView

In your menu xml just add an item and set the actionViewClass to ``. Since you are using the support library you have to use the namespace of the support library to set the actionViewClass attribute. Your menu xml should look something like this:

<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>

In your Fragment or Activity you have to inflate this menu xml like usual, then you can look for the MenuItem which contains the SearchView and implement the OnQueryTextListener which we are going to use to listen for changes to the text entered into the SearchView:

@Override
public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
    inflater.inflate(R.menu.menu_main, menu);

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

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

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

And now the SearchView is ready to be used. We will implement the filter logic later on in onQueryTextChange() once we are finished implementing the Adapter.

2) Setting up the Adapter

First and foremost this is the model class I am going to use for this example:

public class ExampleModel {

    private final String mText;

    public ExampleModel(String text) {
        mText = text;
    }

    public String getText() {
        return mText;
    }
}

It's just your basic model which will display a text in the RecyclerView. This is the layout I am going to use to display the text:

<?xml version="1.0" encoding="utf-8"?>
<FrameLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:clickable="true"
    android:background="?attr/selectableItemBackground">

    <TextView
        android:id="@+id/tvText"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:padding="8dp"/>

</FrameLayout>

And the ViewHolder I am using looks like this:

public class ExampleViewHolder extends RecyclerView.ViewHolder {

    private final TextView tvText;

    public ExampleViewHolder(View itemView) {
        super(itemView);

        tvText = (TextView) itemView.findViewById(R.id.tvText);
    }

    public void bind(ExampleModel model) {
        tvText.setText(model.getText());
    }
}

Again nothing special. It just sets the text from the ExampleModel to the TextView in our layout. Now we can finally come to the really interesting part: Writing the Adapter. I am going to skip over the basic implementation of the Adapter and am instead going to concentrate on the parts which are relevant for the SearchView. This is the basic implementation of the Adapter I started out with:

public class ExampleAdapter extends RecyclerView.Adapter<ExampleViewHolder> {

    private final LayoutInflater mInflater;
    private List<ExampleModel> mModels;

    public ExampleAdapter(Context context, List<ExampleModel> models) {
        mInflater = LayoutInflater.from(context);
        mModels = new ArrayList<>(models);
    }

    @Override
    public ExampleViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
        final View itemView = mInflater.inflate(R.layout.item_example, parent, false);
        return new ExampleViewHolder(itemView);
    }

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

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

    public void setModels(List<ExampleModel> models) {
        mModels = new ArrayList<>(models);
    }
}

Basically this is all you need to make this work. You can filter items in onQueryTextChange() and use the setModels() method to change the models in the Adapter and then call notifyDatasetChanged() on the Adapter to update the RecyclerView. Or at least that would have been the way to do this with a ListView. But the RecyclerView brings a whole new element to the table which we can take advantage off: out-of-the-box support for item animations!

3) Getting the Adapter ready for item animations

The first thing we have to do is define three helper methods which enable us to add, remove or move items around in the Adapter. Those methods will automatically call the required notify... method to trigger the item animation that goes along with it.

public ExampleModel removeItem(int position) {
    final ExampleModel model = mModels.remove(position);
    notifyItemRemoved(position);
    return model;
}

public void addItem(int position, ExampleModel model) {
    mModels.add(position, model);
    notifyItemInserted(position);
}

public void moveItem(int fromPosition, int toPosition) {
    final ExampleModel model = mModels.remove(fromPosition);
    mModels.add(toPosition, model);
    notifyItemMoved(fromPosition, toPosition);
}

Again nothing special. We just modify the internal list of objects in the Adapter by either removing, adding or moving objects and once we are done call a notify... method.

Now we are going to implement a method which will animate between the List of objects currently displayed in the Adapter to the filtered List we are going to supply to the method.

public void animateTo(List<ExampleModel> models) {
    applyAndAnimateRemovals(models);
    applyAndAnimateAdditions(models);
    applyAndAnimateMovedItems(models);
}

The three methods contained in animateTo() do all the work here, but the order is important! The most difficult part about animating multiple items like this is keeping track of indexes. What I mean by that is that if for example you add an item then all items below the item you added are moved down. Equally if you remove an item all items below it are moved up. This is a big problem because all notify...() methods which trigger the item animations require the index of an item. If you are not careful and add or remove items and then try to call the notify... methods you are going to end up with weird glitchy animations or even an ArrayIndexOutOfBoundsException.

We do two things to greatly simplify this problem for us:

As I mentioned above we supply the filtered List to the Adapter by passing it into the animateTo() method. The first step is to remove all items which do not exist in the filtered List anymore. The next step is to add all items which did not exist in the original List but do in the filtered List. The final step is to move all items which exist in both Lists. This is exactly what the three methods in animateTo() do.

Now we are going to look at the implementation of those three methods.

Lets start in order with applyAndAnimateRemovals():

private void applyAndAnimateRemovals(List<ExampleModel> newModels) {
    for (int i = mModels.size() - 1; i >= 0; i--) {
        final ExampleModel model = mModels.get(i);
        if (!newModels.contains(model)) {
            removeItem(i);
        }
    }
}

As you can see this method iterates through the internal List of the Adapter backwards and checks if each item is contained in the new filtered List. If it is not it calls removeItem(). The reason we iterate backwards is to avoid having to keep track of an offset. If you remove an item all items below it move up. If you iterate through to the List from the bottom up then only items which you have already iterated over are moved.

Now lets look at applyAndAnimateAdditions():

private void applyAndAnimateAdditions(List<ExampleModel> newModels) {
    for (int i = 0, count = newModels.size(); i < count; i++) {
        final ExampleModel model = newModels.get(i);
        if (!mModels.contains(model)) {
            addItem(i, model);
        }
    }
}

It basically does the same thing as applyAndAnimateRemovals() but instead of iterating through the internal List of the Adapter it iterates through the filtered List and checks if the item exists in the internal List. If it does not it calls addItem().

And finally lets look at applyAndAnimateMovedItems():

private void applyAndAnimateMovedItems(List<ExampleModel> newModels) {
    for (int toPosition = newModels.size() - 1; toPosition >= 0; toPosition--) {
        final ExampleModel model = newModels.get(toPosition);
        final int fromPosition = mModels.indexOf(model);
        if (fromPosition >= 0 && fromPosition != toPosition) {
            moveItem(fromPosition, toPosition);
        }
    }
}

This method implements a more complicated logic than the previous two. It is essentially a combination of applyAndAnimateRemovals() and applyAndAnimateAdditions() but with a twist. You have to realize that at this point applyAndAnimateRemovals() and applyAndAnimateAdditions() have already been called. So we have removed all the items that need to be removed and we added all new items which need to be added. So the internal List of the Adapter and the filtered List contain the exactly same items, but they may be in a different order. What applyAndAnimateMovedItems() now does is it iterates through the filtered List backwards and looks up the index of each item in the internal List. If it detects a difference in the index it calls moveItem() to bring the internal List of the Adapter in line with the filtered List.

And with that our Adapter is complete. It can now display items and automatically triggers appropriate animations as we filter the List of objects. The only thing missing now is to connect the SearchView to the RecyclerView!

One thing I should still mention is that while this is a very simple approach to animating the items it is by far not the most efficient one. But for most use cases it should be more than enough and once you understand the gist of it you can implement it very quickly.

4) Implementing the filter logic

One thing in your question which caught my eye is that you maintain the list of items you want to display directly in the Adapter. While the Adapter of course has to have a List of items internally you should not completely maintain the List in there. The Adapter - as the name implies - should just turn Objects into Views. You give it a List of Objects and the RecyclerView gets a View representing each Object. What the Adapter is definitely not responsible for is creating those Objects.

To implement the filter logic we first have to define a List of all possible Objects. As I mentioned above we will do that not inside the Adapter, but outside in the Fragment or Activity which contains the RecyclerView. The basic implementation (in my case for a Fragment) looks like this:

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

@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
    final View view = inflater.inflate(R.layout.fragment_main, container, false);

    mRecyclerView = (RecyclerView) view.findViewById(R.id.recyclerView);

    return view;
}

@Override
public void onViewCreated(View view, Bundle savedInstanceState) {
    super.onViewCreated(view, savedInstanceState);
    setHasOptionsMenu(true);

    mRecyclerView.setLayoutManager(new LinearLayoutManager(getActivity()));

    mModels = new ArrayList<>();

    for (String movie : MOVIES) {
        mModels.add(new ExampleModel(movie));
    }

    mAdapter = new ExampleAdapter(getActivity(), mModels);
    mRecyclerView.setAdapter(mAdapter);
}

Again nothing special. We setup the RecyclerView and instantiate the Adapter. We create a List of items and store that in a field. This list will be our reference. It contains all possible items which we will filter with the SearchView. In the above example MOVIES is a String[] I defined which contains my test data.

Now we can go back to onQueryTextChange() which we defined earlier and start implementing the filter logic:

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

This is again pretty straight forward. We call the method filter() and pass in our reference List of objects and the query string. We then call animateTo() on the Adapter and pass in the filtered List returned by filter(). We also have to call scrollToPosition(0) on the RecyclerView to ensure that the user can always see all items when searching for something. Otherwise the RecyclerView might stay in a scrolled down position while filtering and subsequently hide a few items. Scrolling to the top ensures a better user experience while searching.

The only thing left to do now is to implement filter() itself:

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

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

The first thing we do here is call toLowerCase() on the query string. We don't want our search function to be case sensitive and by calling toLowerCase() on all strings we compare we can ensure that we return the same results regardless of case. filter() basically just iterates through all the models in the List we passed into it and checks if the query string is contained in the text of the model. If it is then the model is added to the filtered List.

And that is pretty much it! If you run your app now you should be able to filter the data in the RecyclerView with the SearchView and this whole thing runs on Froyo (Android 2.2, API level 7) and above! And starting with Honeycomb (Android 3.0, API level 11) all changes to the dataset displayed in the RecyclerView will be animated automatically! I realize that this is a very detailed description which probably makes this whole thing seem more complicated than it really is. I suggest you look at the working example in the GitHub Repository I linked to above if you are having trouble understanding a specific aspect of this whole thing.