listview 通过筛选全部城市显示出搜索的城市

private List<Map<String, Object>> cityList;

adapter = new FilterAdapter(getContext(), cityList);//
adapter.getFilter().filter( "bj");
adapter.setFilterType(FilterAdapter.FILTER_BODY);
lvCitys.setAdapter(adapter);

public class FilterAdapter extends BaseAdapter implements Filterable {

   public static final int FILTER_HEAD = 0;// 从头开始过滤
   public static final int FILTER_FOOT = 1;// 从后开始过滤
   public static final int FILTER_BODY = 2;// 任意过滤

   private Context context;
   List<Map<String, Object>> cityList;
   private List<String> list = new ArrayList<String>();
   private List<String> spylist = new ArrayList<String>();
   private boolean needSort = false;// 是否需要排序
   private ArrayFilter filter;// 过滤器
   private int filterType = FILTER_BODY;// 过滤类别，默认从头开始过滤
   private Event mFilterFinish = new Event(EventType.FILTER_CITY_FINISH);
   private Event choseCity = new Event(EventType.CHOSE_CITY);

   public FilterAdapter(Context context, List<Map<String, Object>> obj) {
      this.context = context;
      cityList = obj;
      for (int i = 0; i < obj.size(); i++) {
         this.list.add(obj.get(i).get("name").toString());
         this.spylist.add(obj.get(i).get("spy").toString());
      }
   }

   // 返回false后Item间的分割线消失
   @Override
   public boolean areAllItemsEnabled() {
      return false;
   }

   // 带有“－”的不可操作，通常和areAllItemsEnabled一起使用。
   @Override
   public boolean isEnabled(int position) {
      if( position >= list.size())
      {
         return false;
      }
      return !list.get(position).startsWith("-");// 此处根据需求灵活处理
   }

   public int getCount() {
      return list.size();
   }

   public Object getItem(int position) {
      return list.get(position);
   }

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

   public View getView(int position, View convertView, ViewGroup parent) {
        View v;
        final int p = position;
      if (convertView == null) {
            v = LayoutInflater.from(context).inflate(
               R.layout.list_tip_item, parent, false);
      } else {
            v = convertView;
      }

        TextView tv = (TextView)v.findViewById(R.id.list_item_tip);
        if(tv != null)
          tv.setText(list.get(position));
        v.setOnClickListener(new OnClickListener() {
         
         @Override
         public void onClick(View arg0) {
            String name = list.get(p);
            int code = getAdminCodeByName(name);
            if (code != 0) {
               SearchMod.Instance().setSearchAdminName(name);
               SearchMod.Instance().setSearchAdminCode(code);
            }

            String spy = getAdminSpyByName(name);

            _Admin admin = new _Admin(name, spy, code);
            AdminManager am = new AdminManager();
            if (am != null)
               am.insert(admin);
            choseCity.addParam("cityname", name);
            EventManager.trigger(choseCity);
         }
      });
      return v;
   }
   
   private String getAdminSpyByName(String name) {
      String spy = null;
      for (int i = 0; i < cityList.size(); i++) {
         if (cityList.get(i).get("name").toString().equals(name)) {
            spy = cityList.get(i).get("spy").toString();
            break;
         }
      }
      return spy;
   }
   
   private int getAdminCodeByName(String name) {
      int code = 0;
      for (int i = 0; i < cityList.size(); i++) {
         if (cityList.get(i).get("name").toString().equals(name)) {
            code = (Integer) cityList.get(i).get("id");
            break;
         }
      }
      return code;
   }
   public List<String> getList() {
      return list;
   }

   public void setList(List<String> list) {
      this.list = list;
   }

   public boolean isNeedSort() {
      return needSort;
   }

   public void setNeedSort(boolean needSort) {
      this.needSort = needSort;
   }

   private List<String> dosort(List<String> list) {
      Collections.sort(list, comparator);
      return list;
   }

   private Comparator<String> comparator = new Comparator<String>() {
      private final Collator collator = Collator.getInstance();

      public int compare(String s1, String s2) {
         return collator.compare(s1, s2);
      }
   };

   @Override
   public Filter getFilter() {
      // TODO Auto-generated method stub
      if (filter == null) {
         filter = new ArrayFilter();
      }
      return filter;
   }

   public int getFilterType() {
      return filterType;
   }

   public void setFilterType(int filterType) {
      this.filterType = filterType;
   }

   private class ArrayFilter extends Filter {

      @Override
      protected FilterResults performFiltering(CharSequence prefix) {
         // TODO Auto-generated method stub
         FilterResults results = new FilterResults();
         if (prefix == null || prefix.length() == 0) {// 没有过滤符就不过滤
            // new
            // ArrayList<String>()表示让ListView一开始的时候什么都没有,而不是全部显示到ListView中
            // new ArrayList<String>(list)表示一开始就让Item全部显示到ListView中
            ArrayList<String> l = new ArrayList<String>(list);
            results.values = l;
            results.count = l.size();
         } else {

            String prefixString = prefix.toString().toUpperCase();
            Log.i("FilterAdapter", "prefixString = " + prefixString);

            final ArrayList<String> values = new ArrayList<String>(list);

            final int count = values.size();

            ArrayList<String> newValues = new ArrayList<String>(list);

            for (int i = 0; i < count; i++) {
               final String value = values.get(i);// 原始字符串
               final String valueText = value.toString().toLowerCase();
               final String spy = spylist.get(i).toString();
               Log.i("FilterAdapter", "value = " + value);
               Log.i("FilterAdapter", "valueText = " + valueText);
               Log.i("FilterAdapter", "spy = " + spy);

               // 匹配核心代码，需要自己实现，这里只提供了基本的过滤类型
               switch (filterType) {
               case FILTER_HEAD:
                  if (!valueText.startsWith(prefixString)) {// 过滤掉不需要的项
                     newValues.remove(value);
                     Log.i("FilterAdapter", "remove FILTER_HEAD " + value + ",lenght = " + newValues.size());
                  }
                  break;
               case FILTER_FOOT:
                  if (!valueText.endsWith(prefixString)) {// 过滤掉不需要的项
                     newValues.remove(value);
                     Log.i("FilterAdapter", "remove FILTER_FOOT " + value + ",lenght = " + newValues.size());
                  }
                  break;
               case FILTER_BODY:
                  if (spy.indexOf(prefixString) == -1 && valueText.indexOf(prefixString) == -1) {
                     newValues.remove(value);
                     Log.i("FilterAdapter", "remove FILTER_BODY " + value + ",lenght = " + newValues.size());
                  } /*else if (valueText.indexOf(prefixString) != -1) {// 过滤掉不需要的项
                     newValues.add(value);
                     Log.i("FilterAdapter", "add FILTER_BODY valueText " + value + ",lenght = " + newValues.size());
                  }*/
                  break;

               default:
                  break;
               }
               Log.i("FilterAdapter", "newValues.size() = " + newValues.size());
            }

            results.values = newValues;
            results.count = newValues.size();
            Log.i("FilterAdapter", "newValues.size() = " + newValues.size() +", results.count = " + results.count);
         }

         return results;
      }

      @Override
      protected void publishResults(CharSequence constraint,
            FilterResults results) {
         // TODO Auto-generated method stub
         list = (List<String>) results.values;
         /*if (results.count > 0) {
            notifyDataSetChanged();
         } else {
            notifyDataSetInvalidated();
         }*/
         EventManager.trigger(mFilterFinish);
      }

   }
}