Java 刷新列表视图项

我的问题是，我在列表视图项上实现了带有filterable的搜索视图。它工作得很好，但是在执行搜索并且

searchView

为空后，我无法获取前面的项目。我尝试了

notifydatasetchange

，但对我无效。我该怎么办

....
 private ListView mListNotes;
 NoteListAdapter na;

  protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mListNotes = (ListView) findViewById(R.id.main_listview);
        mListNotes.setTextFilterEnabled(true);

    }
    @Override
    protected void onResume() {
        super.onResume();
        //load data into the listview and display
        mListNotes.setAdapter(na); 
   }

    @Override
    public boolean onQueryTextChange(String query) {
        if (!query.equals("")) {
            na.getFilter().filter(query);  // filter listView items when text is inputted.

        } else {
         na.notifyDataSetChanged();         // what do i put here to refresh my list view after search?

        }
        return false;
    }
}

// ListView Adapter


class NoteListAdapter extends ArrayAdapter<Note> implements Filterable{
    List<Note> objects;
    private List<Note> mStringFilterList;
     Filter filter;
    private static final int WRAP_CONTENT_LENGTH = 5;
    public NoteListAdapter(Context context, int resource, List<Note> objects) {
        super(context, resource, objects);
        this.objects = objects;
      this.mStringFilterList = objects;

    }

   @Override
  public int getCount() {
      return objects.size();
   }

    @Nullable
   @Override
    public Note getItem(int position) {
       return objects.get(position);
    }

    @Override
   public long getItemId(int position) {
       return position;
   }


    @Override
    public Filter getFilter() {
        filter = new Filter() {
            @Override
            protected FilterResults performFiltering(CharSequence constraint) {
                ArrayList<Note> tempList= new ArrayList<>();
                FilterResults results = new FilterResults();
                if (constraint != null && objects != null) {
                    for(Note singleNote : objects) {
                        if( singleNote.getTitle().contains(constraint))
                            tempList.add(singleNote);
                    }
                    results.values = tempList;
                    results.count = tempList.size();
                }

                return results;
            }
            @Override
            protected void publishResults(CharSequence constraint, FilterResults results) {
                objects = (ArrayList<Note>) results.values;
                notifyDataSetChanged();

            }
        };
        return filter;

        }


    }


}

。。。。
私有ListView mListNotes；
注：A；
创建时受保护的void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.activity_main）；
mListNotes=（ListView）findViewById（R.id.main\u ListView）；
mListNotes.setTextFilterEnabled（true）；
}
@凌驾
受保护的void onResume（）{
super.onResume（）；
//将数据加载到listview并显示
mListNotes.setAdapter（na）；
}
@凌驾
公共布尔onQueryTextChange（字符串查询）{
如果（！query.equals（“”）{
na.getFilter（）.filter（查询）；//输入文本时过滤listView项。
}否则{
na.notifyDataSetChanged（）；//在搜索后，我应该在这里放置什么来刷新列表视图？
}
返回false；
}
}
//列表视图适配器
类NoteListAdapter扩展ArrayAdapter实现可筛选{
列出对象；
私有列表mStringFilterList；
过滤器；
私有静态最终整型内容长度=5；
公共NoteListAdapter（上下文、int资源、列表对象）{
超级（上下文、资源、对象）；
this.objects=对象；
this.mStringFilterList=对象；
}
@凌驾
public int getCount（）{
返回objects.size（）；
}
@可空
@凌驾
公共注释getItem（内部位置）{
返回对象。获取（位置）；
}
@凌驾
公共长getItemId（int位置）{
返回位置；
}
@凌驾
公共过滤器getFilter（）{
过滤器=新过滤器（）{
@凌驾
受保护的筛选器结果性能筛选（CharSequence约束）{
ArrayList tempList=新的ArrayList（）；
FilterResults results=新的FilterResults（）；
if（约束！=null&&objects！=null）{
对于（注意：单个对象）{
if（singleNote.getTitle（）.contains（constraint））
添加（单音符）；
}
results.values=模板列表；
results.count=templast.size（）；
}
返回结果；
}
@凌驾
受保护的void publishResults（CharSequence约束、FilterResults结果）{
objects=（ArrayList）results.values；
notifyDataSetChanged（）；
}
};
回流过滤器；
}
}
}

您正在用过滤后的数据替换原始数据。使用以下代码：

class NoteListAdapter extends ArrayAdapter<Note> implements Filterable {
        List<Note> objects;
        private List<Note> originalList = new ArrayList<>();
        Filter filter;
        private static final int WRAP_CONTENT_LENGTH = 5;

        public NoteListAdapter(Context context, int resource, List<Note> objects) {
            super(context, resource, objects);
            this.objects = objects;
            this.originalList.addAll(objects);
        }

        @Override
        public int getCount() {
            return objects.size();
        }

        @Nullable
        @Override
        public Note getItem(int position) {
            return objects.get(position);
        }

        @Override
        public long getItemId(int position) {
            return position;
        }


        @Override
        public Filter getFilter() {
            filter = new Filter() {
                @Override
                protected FilterResults performFiltering(CharSequence constraint) {
                    ArrayList<Note> tempList = new ArrayList<>();
                    FilterResults results = new FilterResults();
                    if (objects != null) {
                        if(constraint != null && !constraint.equals("")) {
                            for (Note singleNote : objects) {
                                if (singleNote.getTitle().contains(constraint))
                                    tempList.add(singleNote);
                            }
                            results.values = tempList;
                            results.count = tempList.size();
                        }else {
                            tempList.clear();
                            tempList.addAll(originalList);
                            results.values = tempList;
                            results.count = tempList.size();
                        }
                    }

                    return results;
                }

                @Override
                protected void publishResults(CharSequence constraint, FilterResults results) {
                    objects = (ArrayList<Note>) results.values;
                    notifyDataSetChanged();
                }
            };
            return filter;
        }
    }

class NoteListAdapter扩展ArrayAdapter实现可过滤{
列出对象；
private List originalList=new ArrayList（）；
过滤器；
私有静态最终整型内容长度=5；
公共NoteListAdapter（上下文、int资源、列表对象）{
超级（上下文、资源、对象）；
this.objects=对象；
this.originalList.addAll（对象）；
}
@凌驾
public int getCount（）{
返回objects.size（）；
}
@可空
@凌驾
公共注释getItem（内部位置）{
返回对象。获取（位置）；
}
@凌驾
公共长getItemId（int位置）{
返回位置；
}
@凌驾
公共过滤器getFilter（）{
过滤器=新过滤器（）{
@凌驾
受保护的筛选器结果性能筛选（CharSequence约束）{
ArrayList tempList=新的ArrayList（）；
FilterResults results=新的FilterResults（）；
如果（对象！=null）{
if（constraint！=null&！constraint.equals（“”）{
对于（注意：单个对象）{
if（singleNote.getTitle（）.contains（constraint））
添加（单音符）；
}
results.values=模板列表；
results.count=templast.size（）；
}否则{
圣殿骑士；
圣殿骑士阿达尔（原教旨主义者）；
results.values=模板列表；
results.count=templast.size（）；
}
}
返回结果；
}
@凌驾
受保护的void publishResults（CharSequence约束、FilterResults结果）{
objects=（ArrayList）results.values；
notifyDataSetChanged（）；
}
};
回流过滤器；
}
}

---

希望有帮助：）

您正在用过滤后的数据替换原始数据。使用以下代码：

class NoteListAdapter extends ArrayAdapter<Note> implements Filterable {
        List<Note> objects;
        private List<Note> originalList = new ArrayList<>();
        Filter filter;
        private static final int WRAP_CONTENT_LENGTH = 5;

        public NoteListAdapter(Context context, int resource, List<Note> objects) {
            super(context, resource, objects);
            this.objects = objects;
            this.originalList.addAll(objects);
        }

        @Override
        public int getCount() {
            return objects.size();
        }

        @Nullable
        @Override
        public Note getItem(int position) {
            return objects.get(position);
        }

        @Override
        public long getItemId(int position) {
            return position;
        }


        @Override
        public Filter getFilter() {
            filter = new Filter() {
                @Override
                protected FilterResults performFiltering(CharSequence constraint) {
                    ArrayList<Note> tempList = new ArrayList<>();
                    FilterResults results = new FilterResults();
                    if (objects != null) {
                        if(constraint != null && !constraint.equals("")) {
                            for (Note singleNote : objects) {
                                if (singleNote.getTitle().contains(constraint))
                                    tempList.add(singleNote);
                            }
                            results.values = tempList;
                            results.count = tempList.size();
                        }else {
                            tempList.clear();
                            tempList.addAll(originalList);
                            results.values = tempList;
                            results.count = tempList.size();
                        }
                    }

                    return results;
                }

                @Override
                protected void publishResults(CharSequence constraint, FilterResults results) {
                    objects = (ArrayList<Note>) results.values;
                    notifyDataSetChanged();
                }
            };
            return filter;
        }
    }

class NoteListAdapter扩展ArrayAdapter实现可过滤{
列出对象；
private List originalList=new ArrayList（）；
过滤器；
私有静态最终整型内容长度=5；
公共NoteListAdapter（上下文、int资源、列表对象）{
超级（上下文、资源、对象）；
this.objects=对象；
this.originalList.addAll（对象）；
}
@凌驾
public int getCount（）{
返回objects.size（）；
}
@可空
@凌驾
公共注释getItem（内部位置）{
返回对象。获取（位置）；
}
@凌驾
公共长条