Wprowadzenie

Ponieważ nie jest to bardzo jasne forma pytania z czym dokładnie masz problemy, napisałem ten krótki przegląd o tym, jak wdrożyć tę funkcję, jeśli nadal masz pytania, nie krępuj się zadać.

Mam działający przykład wszystkiego, o czym mówię tutaj w tym repozytorium GitHub.
Jeśli chcesz dowiedzieć się więcej o przykładowym projekcie odwiedź projekt Strona główna.

W każdym przypadku wynik powinien wyglądać mniej więcej tak:

W każdym razie zaczynajmy.

Tworzenie SearchView

W folderze res/menu utwórz nowy plik o nazwie main_menu.xml. W nim Dodaj element i ustaw actionViewClass na android.support.v7.widget.SearchView. Ponieważ korzystasz z pomocy technicznej biblioteka musisz użyć przestrzeni nazw biblioteki wsparcia, aby ustawić atrybut actionViewClass. Twój plik xml powinien wyglądać mniej więcej tak:

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

W twoim Fragment lub Activity musisz napompować to Menu XML jak zwykle, następnie możesz poszukać MenuItem, który zawiera SearchView i zaimplementować OnQueryTextListener, którego użyjemy do nasłuchania zmian w tekście wprowadzonym do 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) MenuItemCompat.getActionView(searchItem);
    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;
}

A teraz {[25] } jest gotowy do użycia. Zaimplementujemy logikę filtra później w onQueryTextChange() Po zakończeniu implementacji Adapter.

Tworzenie Adapter

Przede wszystkim jest to klasa modelu, której użyję w tym przykładzie:

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

To tylko twój podstawowy model, który wyświetli tekst w RecyclerView. Jest to układ, którego użyję do wyświetlenia tekstu:

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

Jak widzisz używam wiązania danych. Jeśli nigdy wcześniej nie pracowałeś z powiązaniami danych, nie zniechęcaj się! Jest bardzo proste i potężne, jednak nie potrafię wyjaśnić, jak to działa w zakresie tej odpowiedzi.

To jest ViewHolder dla ExampleModel klasy:

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);
    }
}

Teraz możemy wreszcie przejść do naprawdę interesującej części: pisania adaptera. Mam zamiar pominąć podstawową implementację Adapter i zamiast tego zamierzam skoncentrować się na części, które są istotne dla tej odpowiedzi.

Ale najpierw jest jedna rzecz, o której musimy porozmawiać: SortedList klasy.

SortedList

SortedList jest całkowicie niesamowitym narzędziem, które jest częścią RecyclerView biblioteki. Dba o powiadomienie Adapter o zmianach w zbiorze danych i robi to w bardzo skuteczny sposób. Jedyne, co musisz zrobić, to określić kolejność elementów. Musisz to zrobić poprzez wdrożenie compare() metoda, która porównuje dwa elementy w SortedList tak jak Comparator. Ale zamiast sortowania List jest on używany do sortowania elementów w RecyclerView!

SortedList współdziała z Adapter poprzez Callback klasę, którą musisz zaimplementować:

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();
    }
}

W metodach na górze wywołania zwrotnego jak onMoved, onInserted, itd. musisz wywołać równoważną metodę powiadamiania Adapter. Trzy metody na dole compare, areContentsTheSame i areItemsTheSame musisz wdrożyć zgodnie do jakiego rodzaju obiektów chcesz wyświetlić i w jakiej kolejności obiekty te powinny pojawić się na ekranie.

Przejdźmy przez te metody jeden po drugim:

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

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

Teraz spójrzmy na następny metoda:

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

Celem tej metody jest ustalenie, czy zawartość modelu uległa zmianie. SortedList używa tego do określenia, czy zdarzenie change musi zostać wywołane - innymi słowy, jeśli {[41] } powinno skrzyżować starą i nową wersję. Jeśli modelowe klasy mają poprawną implementację equals() i hashCode(), zazwyczaj możesz ją zaimplementować tak jak powyżej. Jeśli dodamy implementację equals() i hashCode() do klasy ExampleModel powinna ona wyglądać tak: to:

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

Szybka Uwaga: Większość IDE, takich jak Android Studio, IntelliJ i Eclipse mają funkcjonalność do generowania equals() i {68]} implementacje dla Ciebie za naciśnięciem przycisku! Więc nie musisz ich wdrażać samodzielnie. Sprawdź w Internecie, jak to działa w IDE!

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

SortedList używa tej metody, aby sprawdzić, czy dwa elementy odnoszą się do tej samej rzeczy. W najprostszych słowach (bez wyjaśnienia, jak SortedList Działa) służy do określenia, czy obiekt jest już zawarty w List i czy należy odtworzyć animację dodaj, Przenieś lub zmień. Jeśli twoje modele mają identyfikator, Zwykle porównujesz tylko identyfikator w tej metodzie. Jeśli nie musisz wymyślić innego sposobu, aby to sprawdzić, ale jednak w końcu wdrożysz to zależy od konkretnej aplikacji. Zazwyczaj najprostszą opcją jest nadanie wszystkim modelom identyfikatora - który może być na przykład głównym polem klucza, jeśli odpytywanie danych z bazy danych.

Z SortedList.Callback poprawnie zaimplementowanym możemy utworzyć instancję SortedList:

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

Jako pierwszy parametr w konstruktorze SortedList musisz przejść klasę swoich Modeli. Innym parametrem jest SortedList.Callback zdefiniowany powyżej.

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 używane do sortowania elementu jest przekazywane in through the constructor, więc możemy użyć tego samego Adapter, nawet jeśli elementy mają być wyświetlane w innej kolejności.

Już prawie skończyliśmy! Ale najpierw potrzebujemy sposobu, aby dodać lub usunąć elementy do Adapter. W tym celu możemy dodać metody do Adapter, które pozwalają nam dodawać i usuwać elementy do 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();
}

Nie musimy tutaj wywoływać żadnych metod powiadamiania, ponieważ SortedList robi to już za pośrednictwem SortedList.Callback! Poza tym realizacja metody te są dość proste z jednym wyjątkiem: metoda remove, która usuwa List modeli. Ponieważ SortedList ma tylko jedną metodę remove, która może usunąć pojedynczy obiekt, musimy zapętlić listę i usunąć modele jeden po drugim. Wywołanie beginBatchedUpdates() na początku partii wszystkich zmian, które zamierzamy wprowadzić do SortedList razem i poprawia wydajność. Kiedy wywołujemy endBatchedUpdates() {[41] } jest powiadamiany o wszystkich zmianach na raz.

Dodatkowo to, co masz aby zrozumieć, że jeśli dodasz obiekt do SortedList i jest już w SortedList, nie zostanie on dodany ponownie. Zamiast tego SortedList używa metody areContentsTheSame(), aby dowiedzieć się, czy obiekt się zmienił - i czy posiada element w RecyclerView zostanie zaktualizowany.

W każdym razie, Zwykle preferuję jedną metodę, która pozwala mi zastąpić wszystkie przedmioty w RecyclerView naraz. Usuń wszystko, czego nie ma w List i dodaj wszystkie elementy, których brakuje w 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();
}

To metoda ponownie grupuje wszystkie aktualizacje razem, aby zwiększyć wydajność. Pierwsza pętla jest odwrotna, ponieważ usunięcie elementu na początku spowoduje bałagan w indeksach wszystkich elementów, które pojawiają się po nim, a to może prowadzić w niektórych przypadkach do problemów, takich jak niespójności danych. Następnie dodajemy List do SortedList używając addAll(), aby dodać wszystkie elementy, które nie są jeszcze w SortedList i - tak jak opisałem powyżej-aktualizujemy wszystkie elementy, które są już w SortedList, ale mają zmieniony.

I z tym Adapter jest kompletna. Całość powinna wyglądać mniej więcej tak:

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();
    }
}

Jedyne czego teraz brakuje to zaimplementowanie filtrowania!

Implementacja logiki filtra

Aby zaimplementować logikę filtra musimy najpierw zdefiniować List wszystkich możliwych modeli. W tym przykładzie tworzę List Z ExampleModel instancji z tablicy filmów:

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);
}

Nic specjalnego się tu nie dzieje, po prostu Utwórz instancję Adapter i ustaw ją na RecyclerView. Następnie tworzymy List modeli z nazw filmów w tablicy MOVIES. Następnie dodajemy wszystkie modele do SortedList.

Teraz możemy wrócić do onQueryTextChange(), które zdefiniowaliśmy wcześniej i rozpocząć implementację logiki filtra:

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

To znowu całkiem proste. Wywołujemy metodę filter() i przekazujemy w List z ExampleModels, jak również łańcuch zapytania. Następnie wywołujemy {[122] } na Adapter i przekazujemy w filtrowanym List zwrócone przez filter(). Musimy również zadzwonić scrollToPosition(0) na RecyclerView, aby upewnić się, że użytkownik zawsze może zobaczyć wszystkie elementy podczas wyszukiwania czegoś. W przeciwnym razie RecyclerView może pozostać w pozycji przewijanej w dół podczas filtrowania, a następnie ukryć kilka elementów. Przewijanie do góry zapewnia lepsze wrażenia użytkownika podczas wyszukiwania.

Jedyne, co pozostało do zrobienia, to zaimplementować filter() siebie:

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

Pierwszą rzeczą, którą tutaj robimy, jest wywołanie toLowerCase() na łańcuchu zapytania. My nie chcemy, aby nasza funkcja wyszukiwania uwzględniała wielkość liter i wywołując toLowerCase() na wszystkich porównywanych łańcuchach możemy zapewnić, że zwracamy te same wyniki niezależnie od wielkości liter. Następnie po prostu iteruje przez wszystkie modele w List przekazaliśmy do niego i sprawdza, czy łańcuch zapytania jest zawarty w tekście modelu. Jeśli tak, to model jest dodawany do filtrowanego List.

I to wszystko! Powyższy kod będzie działał na poziomie API 7 i wyższym, a zaczynając od poziomu API 11 otrzymasz element animacje za darmo!

Zdaję sobie sprawę, że jest to bardzo szczegółowy opis, który prawdopodobnie sprawia, że cała sprawa wydaje się bardziej skomplikowana niż w rzeczywistości jest, ale jest sposób, w jaki możemy uogólnić ten cały problem i uczynić implementację Adapter opartą na {45]} znacznie prostszym.

Uogólnienie problemu i uproszczenie adaptera

W tym dziale Nie będę wdawać się zbytnio w szczegóły-częściowo dlatego, że biegnę z limitem znaków dla odpowiedzi na temat przepełnienia stosu, ale również dlatego, że większość z nich została już wyjaśniona powyżej - ale podsumowując zmiany: możemy zaimplementować klasę base Adapter, która już zajmuje się radzeniem sobie z SortedList, jak również wiążąc modele do ViewHolder instancji i zapewnia wygodny sposób zaimplementowania Adapter w oparciu o SortedList. W tym celu musimy zrobić dwie rzeczy:

• musimy stworzyć interfejs ViewModel, który wszystkie klasy modelu muszą zaimplementować
• musimy stworzyć ViewHolder podklasa definiująca metodę bind(), której Adapter może używać do automatycznego wiązania modeli.

Pozwala nam to po prostu skupić się na treści, która ma być wyświetlana w RecyclerView poprzez implementację modeli i odpowiadających im implementacji {42]}. Używając tej klasy bazowej nie musimy się martwić o szczegóły Adapter i jej SortedList.

SortedListAdapter

Ze względu na limit znaków odpowiedzi na StackOverflow I nie można przejść przez każdy etap implementacji tej klasy bazowej ani nawet dodać pełnego kodu źródłowego tutaj, ale można znaleźć Pełny kod źródłowy tej klasy bazowej-nazwałem ją {149]} - w tym GitHub Gist.

Aby ułatwić Ci życie, opublikowałem bibliotekę na jCenter, która zawiera SortedListAdapter! Jeśli chcesz go użyć, wszystko, co musisz zrobić, to dodać tę zależność do kompilacji aplikacji.plik:

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

Możesz znaleźć więcej informacji na temat ta biblioteka na stronie głównej biblioteki.

Korzystanie z SortedListAdapter

Aby skorzystać z SortedListAdapter musimy wprowadzić dwie zmiany:

• Zmień ViewHolder tak, aby rozszerzył SortedListAdapter.ViewHolder. Parametrem typu powinien być model, który powinien być związany z tym ViewHolder - w tym przypadku ExampleModel. Musisz powiązać dane z modelami w performBind() zamiast bind().

  public class ExampleViewHolder extends SortedListAdapter.ViewHolder<ExampleModel> {
  
      private final ItemExampleBinding mBinding;
  
      public ExampleViewHolder(ItemExampleBinding binding) {
          super(binding.getRoot());
          mBinding = binding;
      }
  
      @Override
      protected void performBind(ExampleModel item) {
          mBinding.setModel(item);
      }
  }
  

• Upewnij się, że wszystkie twoje modele wdrażają ViewModel interfejs:

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

Potem musimy tylko zaktualizować ExampleAdapter, aby rozszerzyć SortedListAdapter i usunąć wszystko, czego już nie potrzebujemy. Parametr type powinien być typem modelu, z którym pracujesz-w tym przypadku ExampleModel. Ale jeśli pracujesz z różnymi typami modeli, ustaw parametr type na 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);
    }
}

Potem już po nas! Jednak jeszcze jedna rzecz do wspomnienia: SortedListAdapter nie ma tego samego add(), remove() lub replaceAll() metody nasze oryginalne ExampleAdapter miały. Używa oddzielnego obiektu Editor do modyfikowania pozycji na liście, do których można uzyskać dostęp za pomocą metody edit(). Jeśli chcesz usunąć lub dodać elementy, musisz wywołać edit(), a następnie dodać i usunąć elementy na tej instancji Editor, A gdy skończysz, wywołaj commit() na nim, aby zastosować zmiany do SortedList:

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

Wszystkie wprowadzone w ten sposób zmiany są zestawiane razem, aby zwiększyć wydajność. Metodę replaceAll() zaimplementowaliśmy w rozdziały powyżej są również obecne na tym Editor obiekcie:

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

Jeśli zapomnisz zadzwonić commit() wtedy żadna z Twoich zmian nie zostanie zastosowana!