Android 筛选ListView扩展BaseAdapter

在我的应用程序中，我从解析数据库中检索所有餐厅的名称，并在列表顶部添加了一个搜索栏，以便在列表中搜索名称。我在ListViewAdWater中遇到了一个问题

public class ListViewAdapter extends BaseAdapter implements Filterable {
// Declare Variables
Context mContext;
LayoutInflater inflater;
//private List<Names> namelist =     null;

公共类ListViewAdapter扩展BaseAdapter实现可过滤{
//声明变量
语境；
充气机；
//私有列表namelist=null；

//私有ArrayList ArrayList； 专用滤波器

private List<Names> originalData = null;
private List<Names> filteredData = null;


public ListViewAdapter(Activity context, List<Names> namelist) {

    inflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
    this.filteredData = namelist;
    this.originalData = namelist;
    mContext = context;
}

public class ViewHolder {
    TextView name;
}

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

@Override
public Object getItem(int position) {
    return filteredData.get(position);
}

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


public View getView(final int position, View view, ViewGroup parent) {
    final ViewHolder holder;
    if (view == null) {
        holder = new ViewHolder();
        view = inflater.inflate(R.layout.listview_item, null);
        // Locate the TextView in listview_item.xml
        holder.name = (TextView) view.findViewById(R.id.name);
        view.setTag(holder);
    } else {
        holder = (ViewHolder) view.getTag();
    }
    // Set the results into TextView
    holder.name.setText(filteredData.get(position).getName());
    // Listen for ListView Item Click
    view.setOnClickListener(new OnClickListener() {

        @Override
        public void onClick(View arg0) {
            // Send single item click data to SingleItemView Class
            Intent intent = new Intent(mContext, SingleItemView.class);
            // Pass all data number
            intent.putExtra("name", (filteredData.get(position).getName()));
            // Start SingleItemView Class
            mContext.startActivity(intent);
        }
    });
    return view;
}


@Override
public Filter getFilter() {
    if (filter == null) filter = new Filter() {
        @Override
        protected FilterResults performFiltering(CharSequence constraint) {
            String constraintStr = constraint.toString().toLowerCase(Locale.getDefault());
            FilterResults result = new FilterResults();

            if (constraintStr != null & constraintStr.length() > 0) {
                ArrayList<Names> filterItems = new ArrayList<Names>();

                synchronized (this) {
                    for (Names item : originalData) {
                        if (item.getName().toLowerCase(Locale.getDefault()).startsWith(constraintStr)) {
                            filterItems.add(item);
                        }
                    }
                    result.count = filterItems.size();
                    result.values = filterItems;
                }
            } else {
                synchronized (this) {
                    result.count = originalData.size();
                    result.values = originalData;
                }
            }
            return result;

        }

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

            if (results.values != null) {
                filteredData= (List<Names>) results.values;
                notifyDataSetChanged();
            }

        }
    };
    return filter;
}

private List originalData=null；
私有列表过滤器数据=null；
公共ListViewAdapter（活动上下文、列表名称列表）{
充气器=（LayoutFlater）context.getSystemService（context.LAYOUT\u充气器\u服务）；
this.filteredData=名称列表；
this.originalData=名称列表；
mContext=上下文；
}
公共类视图持有者{
文本视图名称；
}
@凌驾
public int getCount（）{
返回filteredData.size（）；
}
@凌驾
公共对象getItem（int位置）{
返回filteredData.get（位置）；
}
@凌驾
公共长getItemId（int位置）{
返回位置；
}
公共视图getView（最终整数位置、视图视图、视图组父视图）{
最终持票人；
如果（视图==null）{
holder=新的ViewHolder（）；
视图=充气机。充气（R.layout.listview_项，空）；
//在listview_item.xml中找到TextView
holder.name=（TextView）view.findViewById（R.id.name）；
视图.设置标签（支架）；
}否则{
holder=（ViewHolder）view.getTag（）；
}
//将结果设置为TextView
holder.name.setText（filteredData.get（position.getName（））；
//侦听ListView项目单击
view.setOnClickListener（新的OnClickListener（）{
@凌驾
公共void onClick（视图arg0）{
//将单项单击数据发送到SingleItemView类
意向意向=新意向（mContext，SingleItemView.class）；
//传递所有数据编号
intent.putExtra（“name”，（filteredData.get（position.getName（））；
//启动SingleItemView类
mContext.startActivity（意图）；
}
});
返回视图；
}
@凌驾
公共过滤器getFilter（）{
if（filter==null）filter=new filter（）{
@凌驾
受保护的筛选器结果性能筛选（CharSequence约束）{
字符串constraintStr=constraint.toString（）.toLowerCase（Locale.getDefault（））；
FilterResults结果=新的FilterResults（）；
if（constraintStr！=null&constraintStr.length（）>0）{
ArrayList filterItems=新的ArrayList（）；
已同步（此）{
用于（名称项目：originalData）{
if（item.getName（）.toLowerCase（Locale.getDefault（））.startWith（constraintStr））{
过滤器项。添加（项）；
}
}
result.count=filterItems.size（）；
result.values=过滤器项；
}
}否则{
已同步（此）{
result.count=originalData.size（）；
result.values=原始数据；
}
}
返回结果；
}
@凌驾
受保护的void publishResults（CharSequence约束、FilterResults结果）{
如果（results.values！=null）{
filteredData=（列表）results.values；
notifyDataSetChanged（）；
}
}
};
回流过滤器；
}

使用两个arraylist一个用于原始数据，另一个用于过滤

更新适配器构造函数

    private ArrayList<Names> originalData = null;
            private ArrayList<Names> filteredData = null;

            public adapter(Activity c, ArrayList<Names> list) {
                infalter = (LayoutInflater) c
                        .getSystemService(Context.LAYOUT_INFLATER_SERVICE);

                this.filteredData = list;
                this.originalData = list;
                mContext = c;
            }


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

        @Override
        public Object getItem(int position) {
            return filteredData.get(position);
        }

private ArrayList originalData=null；
私有ArrayList Filteredata=null；
公共适配器（活动c，ArrayList列表）{
infalter=（LayoutInflater）c
.getSystemService（上下文布局\充气机\服务）；
this.filteredData=列表；
this.originalData=列表；
mContext=c；
}
@凌驾
public int getCount（）{
返回filteredData.size（）；
}
@凌驾
公共对象getItem（int位置）{
返回filteredData.get（位置）；
}

在过滤器上

@Override
public Filter getFilter() {
    if (filter == null) filter = new Filter() {
          @Override
            protected FilterResults performFiltering(CharSequence constraint) {
              String constraintStr = constraint.toString().toLowerCase(Locale.getDefault());
                        FilterResults result = new FilterResults();

                        if (constraintStr != null & constraintStr.length() > 0) {
                           ArrayList<Names> filterItems = new ArrayList<Names>();

                            synchronized (this) {
                                for (ContactInfo item : originalData) {
                                    if (item.name.toLowerCase(Locale.getDefault()).startsWith(constraintStr)) {
                                        filterItems.add(item);
                                    }
                                }
                                result.count = filterItems.size();
                                result.values = filterItems;
                            }
                        } else {
                            synchronized (this) {
                                result.count = originalData.size();
                                result.values = originalData;
                            }
                        }
                        return result;

    }

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

            if (results.values != null) {
                namelist = (List<Names>) results.values;
                notifyDataSetChanged();
            }

        }
    };
    return filter;
}

@覆盖
公共过滤器getFilter（）{
if（filter==null）filter=new filter（）{
@凌驾
受保护的筛选器结果性能筛选（CharSequence约束）{
字符串constraintStr=constraint.toString（）.toLowerCase（Locale.getDefault（））；
FilterResults结果=新的FilterResults（）；
if（constraintStr！=null&constraintStr.length（）>0）{
ArrayList filterItems=新的ArrayList（）；
已同步（此）{
用于（联系人信息项：originalData）{
if（item.name.toLowerCase（Locale.getDefault（））.startsWith（constraintStr））{
过滤器项。添加（项）；
}
}
result.count=filterItems.size（）；
result.values=过滤器项；
}
}否则{
已同步（此）{
result.count=originalData.size（）；
result.values=原始数据；
}
}
返回结果；
}
@凌驾
受保护的void publishResults（CharSequence约束、FilterResults结果）{
如果（results.values！=null）{
名称列表=（列表）results.values；
notifyDataSetChanged（）；
}
}
};
回流过滤器；
}

我的电脑仍然有问题