Sieve - Utility classes to allow filtering a master list of items

Filter.java

package com.vinaysshenoy.sieve;

import java.util.List;

/**
 * Created by vinaysshenoy on 03/05/17.
 */

public interface Filter<T> {

    boolean allow(List<T> items, T item);
}

Sieve.java

package com.vinaysshenoy.sieve;

import android.support.annotation.NonNull;
import android.support.annotation.Nullable;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

/**
 * Created by vinaysshenoy on 03/05/17.
 */

public class Sieve<T> {

    private final List<Filter<T>> filters;
    private List<T> masterList;
    private List<T> filteredList;
    private FilterCallbacks<T> filterCallbacks;

    public Sieve(@Nullable FilterCallbacks<T> filterCallbacks) {
        filters = new CopyOnWriteArrayList<>();
        masterList = Collections.emptyList();
        filteredList = Collections.emptyList();
        this.filterCallbacks = filterCallbacks;
    }

    public void addFilter(@NonNull Filter<T> filter, boolean filterNow) {
        filters.add(filter);
        if(filterNow) {
            filter();
        }
    }

    public void addFilter(@NonNull Filter<T> filter) {
        addFilter(filter, false);
    }

    public void removeFilter(@NonNull Filter<T> filter, boolean filterNow) {
        filters.remove(filter);
        if(filterNow) {
            filter();
        }
    }

    public void removeFilter(@NonNull Filter<T> filter) {
        removeFilter(filter, false);
    }

    public void filter() {
        final List<T> itemsToFilter = new ArrayList<>(masterList);
        T item;
        for (Filter<T> filter : filters) {
            final Iterator<T> iterator = itemsToFilter.iterator();
            while (iterator.hasNext()) {
                item = iterator.next();
                if(!filter.allow(itemsToFilter, item)) {
                    iterator.remove();
                }
            }
        }
        filteredList = itemsToFilter;
        if(filterCallbacks != null) {
            filterCallbacks.onFilterComplete(filteredList);
        }
    }

    @NonNull
    public List<T> masterList() {
        return Collections.unmodifiableList(masterList);
    }

    @NonNull
    public List<T> filteredList() {
        return Collections.unmodifiableList(filteredList);
    }

    public void setMasterList(@NonNull List<T> items, boolean filterNow) {
        masterList = new ArrayList<>(items);
        if(filterNow) {
            filter();
        }
    }

    public interface FilterCallbacks<T> {

        void onFilterComplete(List<T> items);
    }
}