Liste Görünümü Filtresi Android

Android'de bir liste görünümü oluşturdum ve listenin üstüne düzenleme metni eklemek istiyorum ve kullanıcı metin girdiğinde liste kullanıcı girdisine göre filtrelenecek

Liste adaptörünü android'de filtrelemenin bir yolu varsa lütfen bana söyleyebilir mi?

Liste görünümünüzün üstüne .xml düzen dosyasında bir EditText ekleyin. Ve aktivitenizde / parçanızda ..

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

Buradaki temel , düzenleme metninize bir OnTextChangeListener eklemek ve geri arama yönteminin içinde, listview'inizin adaptörüne filtre uygulamaktır.

DÜZENLE

Özel BaseAdapter'ınıza filtre almak için Filtrelenebilir arabirimi uygulamanız gerekir .

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

İçinde performFiltering () veritabanınızda değerlere arama sorgusunun fiili karşılaştırma yapmak gerekir. Sonucu , publishResults () yöntemine iletecektir .

Adaptörünüzü Filtrelenebilir uygulayın:

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

sonra Filtre sınıfınızı oluşturun:

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

}

bu sayede adaptörünüz Filtrelenebilir, filtre öğesini adaptörün filtresine geçirebilir ve işini yapabilirsiniz. Umuyorum ki faydalı olacaktır.

Bu konuyla hala ilgilenen biri varsa, listeleri filtrelemek için en iyi yaklaşımın genel bir Filtre sınıfı oluşturmak ve bunu Java eski okul SDK paketinde bulunan bazı temel yansıtma / genel tekniklerle kullanmak olduğunu görüyorum. İşte yaptığım şey:

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

Ve daha sonra yapmanız gereken tek şey, filtreyi, adaptör referansınızı, listenizi ve filtreleme için çağrılacak yöntemi ileten bir üye sınıf olarak (muhtemelen View'un "onCreate" içinde) oluşturmaktır:

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

Şu anda eksik olan tek şey, adaptör sınıfındaki "getFilter" yöntemini geçersiz kılmaktır:

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

Hepsi tamam! Listenizi başarılı bir şekilde filtrelemelisiniz - Elbette, filtre algoritmanızı ihtiyacınızı en iyi tanımlayan şekilde uygulamalısınız, aşağıdaki kod sadece bir örnektir. . Umarım yardımcı olmuştur, kendine iyi bak.