ListView实现简单的过滤，排序等控制

ArrayAdapter实际上已经实现了过滤，排序等功能，只是ArrayAdapter太弱了，我们通常不去用它。
本人参考了ArrayAdapter源码写的一个adpater，可以有以下功能：
1，排序（最普通的String排序）
2，过滤（头匹配过滤，尾匹配过滤，任意位置匹配过滤）
3，指定返回需要的项数
3，可以指定其中不允许操作的Item

虽然该类功能也不算强（事实上也没办法强，很多东西都得自定义，无法涵盖所有情况），但总算实现了基本的功能，大家可以根据自己的实际情况在此基础上改。
ArrayAdapter源码：http://gundumw100.iteye.com/admin/blogs/1023902

package com.ql.app;

import java.text.Collator;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

import android.app.Activity;
import android.content.Context;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ArrayAdapter;
import android.widget.BaseAdapter;
import android.widget.Filter;
import android.widget.Filterable;
import android.widget.ListView;
import android.widget.TextView;

public class App extends Activity {
	List<String> dataList;
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        dataList=Array2List(mStrings);
//        ArrayAdapter<String> adapter=new ArrayAdapter<String>(this,android.R.layout.simple_list_item_1, dataList);
        //用法
        ControllableSimpleAdapter adapter=new ControllableSimpleAdapter(this,dataList);
        adapter.getFilter().filter("!");
        adapter.setMax(ControllableSimpleAdapter.ALL);
        adapter.setNeedSort(true);
        adapter.setFilterType(ControllableSimpleAdapter.FILTER_BODY);
        ListView listview=(ListView)findViewById(R.id.listview);
        listview.setAdapter(adapter);
        
    }
    
    /**
     * 数组转成List
     * @param <T>
     * @param tArray
     * @return
     */
    public static <T extends Object> List<T> Array2List(T[] tArray) {     
        List<T> tList = Arrays.asList(tArray);     
        // List<T> tList = new ArrayList<T>(Arrays.asList(tArray));     
        return tList;     
    }
    
    /**
     * 可控制的简单Adapter
     * @author admin
     *
     */
    private class ControllableSimpleAdapter extends BaseAdapter implements Filterable{
		
		public static final int ALL=-1; //全部需要
		public static final int FILTER_HEAD=0;//从头开始过滤
		public static final int FILTER_FOOT=1;//从后开始过滤
		public static final int FILTER_BODY=2;//任意过滤
		
		private Context context;
		private List<String> list;
		private boolean needSort=false;//是否需要排序
		private ArrayFilter filter;//过滤器
		private int max=ALL;//最多需要的项，默认全部需要
		private int filterType = FILTER_HEAD;//过滤类别，默认从头开始过滤
		
		public ControllableSimpleAdapter(Context context,List<String> list) {
			this.context = context;
            this.list=list;
        }

		//返回false后Item间的分割线消失
        @Override
        public boolean areAllItemsEnabled() {
        	return false;
        }
        
        //带有“－”的不可操作，通常和areAllItemsEnabled一起使用。
        @Override
        public boolean isEnabled(int position) {
        	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) {
            TextView tv;
            if (convertView == null) {
                tv = (TextView) LayoutInflater.from(context).inflate(
                        android.R.layout.simple_expandable_list_item_1, parent, false);
            } else {
                tv = (TextView) convertView;
            }
            tv.setText(list.get(position));
            return tv;
        }
        
        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;
		}
		
		public int getMax() {
			return max;
		}

		public void setMax(int max) {
			this.max = max;
		}
		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 {
			if(needSort&&!list.isEmpty()){//如果需要过滤的话，需要先排序，后过滤，可能会影响性能。
		            	dosort(list);
		            }
					
					String prefixString = prefix.toString().toLowerCase();

					final ArrayList<String> values = new ArrayList<String>(list);
							
					final int count = values.size();

					final ArrayList<String> newValues = new ArrayList<String>(count);
							
					for (int i = 0; i < count; i++) {
						final String value = values.get(i);//原始字符串
						final String valueText = value.toString().toLowerCase();

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

						default:
							break;
						}
						
						if(max>ALL){//不是全部
							if(newValues.size()>max-1){//超过了就舍去
								break;
							}
						}
					}
					
					results.values = newValues;
					results.count = newValues.size();
				}

				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();  
	            }
			}
			
		}
    }
    
    //test data
    private String[] mStrings = {
    		"----------",
    		"Doppelrhamstufel",
    		"Dorset Blue Vinney",
    		"----------",
    		"Babybel",
    		"----------",
    		"Caerphilly",
    		"----------",
            "Abbaye de Belloc",
            "Abbaye du Mont des Cats",
            "Abertam",
            "Abondance",
            "Ackawi",
            "Acorn",
            "Adelost",
            "Affidelice au Chablis",
            "!Afuega'l Pitu",
            "!Airag",
            "!Airedale",
            "!Aisy Cendre",
            "!Allgauer Emmentaler",
            "!Alverca",
            "Ambert",
            "American Cheese!",
            "Ami du Chambertin!",
            "Anejo Enchilado!",
            "Anneau du Vic-Bilh",
            "Anthoriro",
    };
}

评论

3 楼 sunshaoqun 2013-05-08  

过滤后再做排序或许性能就提高了些吧。

2 楼 bdstudyhard 2012-12-18  

1 楼 kikier 2012-07-26  

文章的代码是过滤出不符合条件的？