EasyAdapter - filterable RecyclerViewAdapter

BaseFilterableEasyRecyclerAdapter.java

import android.content.Context;

import java.util.ArrayList;
import java.util.List;

import uk.co.ribot.easyadapter.BaseEasyRecyclerAdapter;
import uk.co.ribot.easyadapter.ItemViewHolder;

public class BaseFilterableEasyRecyclerAdapter<T> extends BaseEasyRecyclerAdapter<T>
{
    // ---------------------------------
    // copied from BaseEasyRecyclerAdapter and adjusted
    // ---------------------------------

    private List<T> mListItems;
    private List<T> mListItemsOriginal;

    public BaseFilterableEasyRecyclerAdapter(Context context, Class<? extends ItemViewHolder> itemViewHolderClass, List<T> listItems) {
        super(context, itemViewHolderClass);
        this.setItems(listItems);
    }

    public BaseFilterableEasyRecyclerAdapter(Context context, Class<? extends ItemViewHolder> itemViewHolderClass) {
        super(context, itemViewHolderClass);
        this.mListItems = new ArrayList();
        this.mListItemsOriginal = new ArrayList();
    }

    public BaseFilterableEasyRecyclerAdapter(Context context, Class<? extends ItemViewHolder> itemViewHolderClass, List<T> listItems, Object listener) {
        super(context, itemViewHolderClass, listener);
        this.setItems(listItems);
    }

    public BaseFilterableEasyRecyclerAdapter(Context context, Class<? extends ItemViewHolder> itemViewHolderClass, Object listener) {
        super(context, itemViewHolderClass, listener);
        this.mListItems = new ArrayList();
        this.mListItemsOriginal = new ArrayList();
    }

    public void setItems(List<T> listItems) {
        this.mListItems = new ArrayList(listItems);
        this.mListItemsOriginal = listItems;
        this.notifyDataSetChanged();
    }

    public void addItem(T item) {
        this.mListItems.add(item);
        this.mListItemsOriginal.add(item);
        this.notifyItemInserted(this.mListItems.indexOf(item));
    }

    public void addItems(List<T> listItems) {
        if(listItems.size() != 0) {
            this.mListItems.addAll(listItems);
            this.mListItemsOriginal.addAll(listItems);
            this.notifyItemRangeInserted(this.mListItems.indexOf(listItems.get(0)), listItems.size());
        }
    }

    public T getItem(int position) {
        return this.mListItems.get(position);
    }

    public int getItemCount() {
        return this.mListItems.size();
    }

    // ---------------------------------
    // extension for animating insert/remove/add
    // ---------------------------------

    public T removeItem(int position) {
        final T item = mListItems.remove(position);
        notifyItemRemoved(position);
        return item;
    }

    public void addItem(int position, T item) {
        mListItems.add(position, item);
        notifyItemInserted(position);
    }

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

    public void animateTo(List<T> items) {
        applyAndAnimateRemovals(items);
        applyAndAnimateAdditions(items);
        applyAndAnimateMovedItems(items);
    }

    private void applyAndAnimateRemovals(List<T> newItems) {
        for (int i = mListItems.size() - 1; i >= 0; i--) {
            final T item = mListItems.get(i);
            if (!newItems.contains(item)) {
                removeItem(i);
            }
        }
    }

    private void applyAndAnimateAdditions(List<T> newItems) {
        for (int i = 0, count = newItems.size(); i < count; i++) {
            final T item = newItems.get(i);
            if (!mListItems.contains(item)) {
                addItem(i, item);
            }
        }
    }

    private void applyAndAnimateMovedItems(List<T> newItems) {
        for (int toPosition = newItems.size() - 1; toPosition >= 0; toPosition--) {
            final T item = newItems.get(toPosition);
            final int fromPosition = mListItems.indexOf(item);
            if (fromPosition >= 0 && fromPosition != toPosition) {
                moveItem(fromPosition, toPosition);
            }
        }
    }

    public void filter(IPredicate<T> predicate)
    {
        List<T> filtered = new ArrayList<>(mListItemsOriginal);

        if (predicate != null)
            filtered = Filter.filter(filtered, predicate);

        animateTo(filtered);
    }
}

Filter.java

import java.util.ArrayList;
import java.util.List;

public class Filter
{
    public synchronized static <T, S extends List<T>> S filter(S target, IPredicate<T> predicate)
    {
        List<T> result = new ArrayList<T>();
        if (target != null)
        {
            for (T element : target)
            {
                if (predicate.apply(element))
                {
                    result.add(element);
                }
            }
        }
        return (S)result;
    }

    public synchronized static <T> List<T> filter(T[] target, IPredicate<T> predicate)
    {
        ArrayList<T> result = new ArrayList<T>();
        if (target != null)
        {
            for (T element : target)
            {
                if (predicate.apply(element))
                {
                    result.add(element);
                }
            }
        }
        return result;
    }
}

IPredicate.java

public interface IPredicate<T> { boolean apply(T type); }