Listenansicht Filter Android

Ich habe eine Listenansicht in Android erstellt und möchte Bearbeitungstext über der Liste hinzufügen. Wenn der Benutzer Text eingibt, wird die Liste nach Benutzereingaben gefiltert

Kann mir jemand bitte sagen, ob es eine Möglichkeit gibt, den Listenadapter in Android zu filtern?

Fügen Sie einen EditText über Ihrer Listenansicht in die XML-Layoutdatei ein. Und in Ihrer Aktivität / Fragment ..

lv = (ListView) findViewById(R.id.list_view);
    inputSearch = (EditText) findViewById(R.id.inputSearch);

// Adding items to listview
adapter = new ArrayAdapter<String>(this, R.layout.list_item, R.id.product_name,    products);
lv.setAdapter(adapter);       
inputSearch.addTextChangedListener(new TextWatcher() {

    @Override
    public void onTextChanged(CharSequence cs, int arg1, int arg2, int arg3) {
        // When user changed the Text
        MainActivity.this.adapter.getFilter().filter(cs);
    }

    @Override
    public void beforeTextChanged(CharSequence arg0, int arg1, int arg2, int arg3) { }

    @Override
    public void afterTextChanged(Editable arg0) {}
});

Grundsätzlich müssen Sie Ihrem Bearbeitungstext einen OnTextChangeListener hinzufügen und innerhalb seiner Rückrufmethode den Filter auf den Adapter Ihrer Listenansicht anwenden.

BEARBEITEN

Um Filter zu Ihrer benutzerdefinierten BaseAdapter Sie "ll Notwendigkeit zu implementieren Filterbare Schnittstelle.

class CustomAdapter extends BaseAdapter implements Filterable {

    public View getView(){
    ...
    }
    public Integer getCount()
    {
    ...
    }

    @Override
    public Filter getFilter() {

        Filter filter = new Filter() {

            @SuppressWarnings("unchecked")
            @Override
            protected void publishResults(CharSequence constraint, FilterResults results) {

                arrayListNames = (List<String>) results.values;
                notifyDataSetChanged();
            }

            @Override
            protected FilterResults performFiltering(CharSequence constraint) {

                FilterResults results = new FilterResults();
                ArrayList<String> FilteredArrayNames = new ArrayList<String>();

                // perform your search here using the searchConstraint String.

                constraint = constraint.toString().toLowerCase();
                for (int i = 0; i < mDatabaseOfNames.size(); i++) {
                    String dataNames = mDatabaseOfNames.get(i);
                    if (dataNames.toLowerCase().startsWith(constraint.toString()))  {
                        FilteredArrayNames.add(dataNames);
                    }
                }

                results.count = FilteredArrayNames.size();
                results.values = FilteredArrayNames;
                Log.e("VALUES", results.values.toString());

                return results;
            }
        };

        return filter;
    }
}

In performFiltering () müssen Sie die Suchabfrage tatsächlich mit Werten in Ihrer Datenbank vergleichen. Das Ergebnis wird an die Methode publishResults () übergeben .

Implementieren Sie Ihren Adapter Filterbar:

public class vJournalAdapter extends ArrayAdapter<JournalModel> implements Filterable{
private ArrayList<JournalModel> items;
private Context mContext;
....

Erstellen Sie dann Ihre Filterklasse:

private class JournalFilter extends Filter{

    @Override
    protected FilterResults performFiltering(CharSequence constraint) {
        FilterResults result = new FilterResults();
        List<JournalModel> allJournals = getAllJournals();
        if(constraint == null || constraint.length() == 0){

            result.values = allJournals;
            result.count = allJournals.size();
        }else{
            ArrayList<JournalModel> filteredList = new ArrayList<JournalModel>();
            for(JournalModel j: allJournals){
                if(j.source.title.contains(constraint))
                    filteredList.add(j);
            }
            result.values = filteredList;
            result.count = filteredList.size();
        }

        return result;
    }
    @SuppressWarnings("unchecked")
    @Override
    protected void publishResults(CharSequence constraint, FilterResults results) {
        if (results.count == 0) {
            notifyDataSetInvalidated();
        } else {
            items = (ArrayList<JournalModel>) results.values;
            notifyDataSetChanged();
        }
    }

}

Auf diese Weise ist Ihr Adapter filterbar. Sie können Filterelemente an den Filter des Adapters übergeben und die Arbeit erledigen. Ich hoffe das wird hilfreich sein.

Falls sich noch jemand für dieses Thema interessiert, finde ich, dass der beste Ansatz zum Filtern von Listen darin besteht, eine generische Filterklasse zu erstellen und diese mit einigen Basisreflexions- / Generika-Techniken zu verwenden, die im Java Old School SDK-Paket enthalten sind. Folgendes habe ich getan:

public class GenericListFilter<T> extends Filter {

    /**
     * Copycat constructor
     * @param list  the original list to be used
     */
    public GenericListFilter (List<T> list, String reflectMethodName, ArrayAdapter<T> adapter) {
        super ();

        mInternalList = new ArrayList<>(list);
        mAdapterUsed  = adapter;

        try {
            ParameterizedType stringListType = (ParameterizedType)
                    getClass().getField("mInternalList").getGenericType();
            mCompairMethod =
                    stringListType.getActualTypeArguments()[0].getClass().getMethod(reflectMethodName);
        }
        catch (Exception ex) {
            Log.w("GenericListFilter", ex.getMessage(), ex);

            try {
                if (mInternalList.size() > 0) {
                    T type = mInternalList.get(0);
                    mCompairMethod = type.getClass().getMethod(reflectMethodName);
                }
            }
            catch (Exception e) {
                Log.e("GenericListFilter", e.getMessage(), e);
            }

        }
    }

    /**
     * Let's filter the data with the given constraint
     * @param constraint
     * @return
     */
    @Override protected FilterResults performFiltering(CharSequence constraint) {
        FilterResults results = new FilterResults();
        List<T> filteredContents = new ArrayList<>();

        if ( constraint.length() > 0 ) {
            try {
                for (T obj : mInternalList) {
                    String result = (String) mCompairMethod.invoke(obj);
                    if (result.toLowerCase().startsWith(constraint.toString().toLowerCase())) {
                        filteredContents.add(obj);
                    }
                }
            }
            catch (Exception ex) {
                Log.e("GenericListFilter", ex.getMessage(), ex);
            }
        }
        else {
            filteredContents.addAll(mInternalList);
        }

        results.values = filteredContents;
        results.count  = filteredContents.size();
        return results;
    }

    /**
     * Publish the filtering adapter list
     * @param constraint
     * @param results
     */
    @Override protected void publishResults(CharSequence constraint, FilterResults results) {
        mAdapterUsed.clear();
        mAdapterUsed.addAll((List<T>) results.values);

        if ( results.count == 0 ) {
            mAdapterUsed.notifyDataSetInvalidated();
        }
        else {
            mAdapterUsed.notifyDataSetChanged();
        }
    }

    // class properties
    private ArrayAdapter<T> mAdapterUsed;
    private List<T> mInternalList;
    private Method  mCompairMethod;
}

Anschließend müssen Sie den Filter nur noch als Elementklasse erstellen (möglicherweise innerhalb des "onCreate" der Ansicht) und dabei Ihre Adapterreferenz, Ihre Liste und die zum Filtern aufzurufende Methode übergeben:

this.mFilter = new GenericFilter<MyObjectBean> (list, "getName", adapter);

Jetzt fehlt nur noch das Überschreiben der Methode "getFilter" in der Adapterklasse:

@Override public Filter getFilter () {
     return MyViewClass.this.mFilter;
}

Alles erledigt! Sie sollten Ihre Liste erfolgreich filtern - Natürlich sollten Sie Ihren Filteralgorithmus auch so implementieren, dass er Ihre Anforderungen am besten beschreibt. Der folgende Code ist nur ein Beispiel. . Hoffe es hat geholfen, pass auf dich auf.