AutoCompleteTextView

AutoCompleteTextView

 

AutoCompleteTextView具有输入提示的功能，但是它的这种提示不适合对股票列表的过滤，如果你玩过股票软件，就会知道只要输入股票名称的首字母或股票代码就会出现符合匹配的股票，这种过滤怎么实现呢？
还有个问题，汉字具有多音字，如何实现多音字的匹配，比如“长江证券”，无论你输入“cjzq”或者“zjzq”都会匹配到它，这都是需要解决的问题！
匹配的关键在于重写BaseAdapter，让它实现Filterable接口，重写其中的getFilter()，如果你参照ArrayAdaper源码的话，写起来就会容易很多，事实上我就是这么做的,^o^
下面看一下源码：

 package  com.ql.util;

 import  java.util.*;

 import  android.content.Context;
 import  android.util.Log;
 import  android.view.*;
 import  android.widget.BaseAdapter;
 import  android.widget.Filter;
 import  android.widget.Filterable;
 import  android.widget.TextView;

 public   class  SearchAdapter<T>  extends  BaseAdapter  implements  Filterable {
     private  List<T> mObjects;

     private  List<Set<String>> pinyinList; //支持多音字,类似:{{z,c},{j},{z},{q,x}}的集合

     private   final  Object mLock =  new  Object();

     private   int  mResource;

     private   int  mFieldId =  0 ;

     private  Context mContext;

     private  ArrayList<T> mOriginalValues;
     private  ArrayFilter mFilter;

     private  LayoutInflater mInflater;

     public   static   final   int  ALL=- 1 ; //全部
     private   int  maxMatch= 10 ; //最多显示多少个可能选项
     //支持多音字
     public  SearchAdapter(Context context, int  textViewResourceId, T[] objects, int  maxMatch) {
         // TODO Auto-generated constructor stub
         init(context, textViewResourceId, 0 , Arrays.asList(objects));
         this .pinyinList = getHanziSpellList(objects);
         this .maxMatch=maxMatch;
     }

     public  SearchAdapter(Context context, int  textViewResourceId, List<T> objects, int  maxMatch) {
         // TODO Auto-generated constructor stub
         init(context, textViewResourceId, 0 , objects);
         this .pinyinList = getHanziSpellList(objects);
         this .maxMatch=maxMatch;
     }

     private   void  init(Context context,  int  resource,  int  textViewResourceId,List<T> objects) {
         mContext = context;
         mInflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
         mResource = resource;
         mObjects = objects;
         mFieldId = textViewResourceId;
     }


     /**
      * 获得汉字拼音首字母列表
      */
     private  List<Set<String>> getHanziSpellList(T[] hanzi){
         List<Set<String>> listSet=new  ArrayList<Set<String>>();
         PinYin4j pinyin=new  PinYin4j();
         for ( int  i= 0 ;i<hanzi.length;i++){
             listSet.add(pinyin.getPinyin(hanzi[i].toString()));
         }
         return  listSet;
     }
     /**
      * 获得汉字拼音首字母列表
      */
     private  List<Set<String>> getHanziSpellList(List<T> hanzi){
         List<Set<String>> listSet=new  ArrayList<Set<String>>();
         PinYin4j pinyin=new  PinYin4j();
         for ( int  i= 0 ;i<hanzi.size();i++){
             listSet.add(pinyin.getPinyin(hanzi.get(i).toString()));
         }
         return  listSet;
     }

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

     public  T getItem( int  position) {
         return  mObjects.get(position);
     }

     public   int  getPosition(T item) {
         return  mObjects.indexOf(item);
     }

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

     public  View getView( int  position, View convertView, ViewGroup parent) {
         return  createViewFromResource(position, convertView, parent, mResource);
     }

     private  View createViewFromResource( int  position, View convertView,
             ViewGroup parent, int  resource) {
         View view;
         TextView text;

         if  (convertView ==  null ) {
             view = mInflater.inflate(resource, parent, false );
         } else  {
             view = convertView;
         }

         try  {
             if  (mFieldId ==  0 ) {
                 text = (TextView) view;
             } else  {
                 text = (TextView) view.findViewById(mFieldId);
             }
         } catch  (ClassCastException e) {
             Log.e("ArrayAdapter" ,
                     "You must supply a resource ID for a TextView" );
             throw   new  IllegalStateException(
                     "ArrayAdapter requires the resource ID to be a TextView" , e);
         }

         text.setText(getItem(position).toString());

         return  view;
     }

     public  Filter getFilter() {
         if  (mFilter ==  null ) {
             mFilter = new  ArrayFilter();
         }
         return  mFilter;
     }

     private   class  ArrayFilter  extends  Filter {
         @Override
         protected  FilterResults performFiltering(CharSequence prefix) {
             FilterResults results = new  FilterResults();

             if  (mOriginalValues ==  null ) {
                 synchronized  (mLock) {
                     mOriginalValues = new  ArrayList<T>(mObjects); //
                 }
             }

             if  (prefix ==  null  || prefix.length() ==  0 ) {
                 synchronized  (mLock) {
 //                  ArrayList<T> list = new ArrayList<T>();//无
                     ArrayList<T> list = new  ArrayList<T>(mOriginalValues); //List<T>
                     results.values = list;
                     results.count = list.size();
                 }
             } else  {
                 String prefixString = prefix.toString().toLowerCase();

                 final  ArrayList<T> hanzi = mOriginalValues; //汉字String
                 final   int  count = hanzi.size();

                 final  Set<T> newValues =  new  HashSet<T>(count); //支持多音字,不重复

                 for  ( int  i =  0 ; i < count; i++) {
                     final  T value = hanzi.get(i); //汉字String
                     final  String valueText = value.toString().toLowerCase(); //汉字String
                     final  Set<String> pinyinSet=pinyinList.get(i); //支持多音字,类似:{z,c}
                     Iterator iterator= pinyinSet.iterator();//支持多音字
                     while  (iterator.hasNext()) { //支持多音字
                         final  String pinyin = iterator.next().toString().toLowerCase(); //取出多音字里的一个字母

                         if  (pinyin.indexOf(prefixString)!=- 1 ) { //任意匹配
                             newValues.add(value);
                         }
                         else   if  (valueText.indexOf(prefixString)!=- 1 ) { //如果是汉字则直接添加
                             newValues.add(value);
                         }
                     }
                     if (maxMatch> 0 ){ //有数量限制
                         if (newValues.size()>maxMatch- 1 ){ //不要太多
                             break ;
                         }
                     }

                 }
                 List<T> list=Set2List(newValues);//转成List
                 results.values = list;
                 results.count = list.size();
             }
             return  results;
         }

         protected   void  publishResults(CharSequence constraint,FilterResults results) {

             mObjects = (List<T>) results.values;
             if  (results.count >  0 ) {
                 notifyDataSetChanged();
             } else  {
                 notifyDataSetInvalidated();
             }
         }
     }

     //List Set 相互转换
     public  <T  extends  Object> Set<T> List2Set(List<T> tList) {
         Set<T> tSet = new  HashSet<T>(tList);
         //TODO 具体实现看需求转换成不同的Set的子类。
         return  tSet;
     }
     public  <T  extends  Object> List<T> Set2List(Set<T> oSet) {
         List<T> tList = new  ArrayList<T>(oSet);
         // TODO 需要在用到的时候另外写构造，根据需要生成List的对应子类。
         return  tList;
     }
 }

在源码当中使用了PinYin4j去获得汉字的首字母，由于可能是多音字，所以将每个汉字的拼音都放在了Set中。当然PinYin4j很多强大的功能在这里都用不到，所以被我统统去掉了，这样大大提高了匹配效率。再看一下PinYin4j.java：

 package  com.ql.util;

 import  java.util.Arrays;
 import  java.util.HashSet;
 import  java.util.Set;

 public   class  PinYin4j {


     public  PinYin4j(){
     }
     /**
      * 字符串集合转换字符串(逗号分隔)
      *
      * @author wyh
      * @param stringSet
      * @return
      */
     public  String makeStringByStringSet(Set<String> stringSet) {
         StringBuilder str = new  StringBuilder();
         int  i =  0 ;
         for  (String s : stringSet) {
             if  (i == stringSet.size() -  1 ) {
                 str.append(s);
             } else  {
                 str.append(s + "," );
             }
             i++;
         }
         return  str.toString().toLowerCase();
     }


     /**
      * 获取拼音集合
      *
      * @author wyh
      * @param src
      * @return Set<String>
      */
     public  Set<String> getPinyin(String src) {
             char [] srcChar;
             srcChar = src.toCharArray();

             //1:多少个汉字
             //2:每个汉字多少种读音
             String[][] temp = new  String[src.length()][];
             for  ( int  i =  0 ; i < srcChar.length; i++) {
                 char  c = srcChar[i];
                 // 是中文或者a-z或者A-Z转换拼音(我的需求，是保留中文或者a-z或者A-Z)
                 if  (String.valueOf(c).matches( "[\\u4E00-\\u9FA5]+" )) {
                         String[] t = PinyinHelper.getUnformattedHanyuPinyinStringArray(c);
                         temp[i] = new  String[t.length];
                         for ( int  j= 0 ;j<t.length;j++){
                             temp[i][j]=t[j].substring(0 , 1 ); //获取首字母
                         }
                 } else   if  ((( int ) c >=  65  && ( int ) c <=  90 )
                         || ((int ) c >=  97  && ( int ) c <=  122 )||c>= 48 &&c<= 57 ||c== 42 ) { //a-zA-Z0-9*
                     temp[i] = new  String[] { String.valueOf(srcChar[i]) };
                 } else  {
                     temp[i] = new  String[] { "null!" };
                 }

             }
             String[] pingyinArray = paiLie(temp);
             return  array2Set(pingyinArray); //为了去掉重复项
     }

     /*
      * 求2维数组所有排列组合情况
      * 比如:{{1,2},{3},{4},{5,6}}共有2中排列,为:1345,1346,2345,2346
      */
     private  String[] paiLie(String[][] str){
         int  max= 1 ;
         for ( int  i= 0 ;i<str.length;i++){
             max*=str[i].length;
         }
         String[] result=new  String[max];
         for ( int  i =  0 ; i < max; i++){
                 String s = "" ;
                 int  temp =  1 ;       //注意这个temp的用法。
                 for ( int  j =  0 ; j < str.length; j++){
                     temp *= str[j].length;
                     s += str[j][i / (max / temp) % str[j].length];
                 }
                 result[i]=s;
         }

         return  result;
     }

     public   static  <T  extends  Object> Set<T> array2Set(T[] tArray) {
         Set<T> tSet = new  HashSet<T>(Arrays.asList(tArray));
         // TODO 没有一步到位的方法，根据具体的作用，选择合适的Set的子类来转换。
         return  tSet;
     }

     /**
      * @param args
      */
     public   static   void  main(String[] args) {
         //nongyeyinheng,nongyeyinhang,nongyeyinxing
         PinYin4j t=new  PinYin4j();
         String str = "农业银行1234567890abcdefghijklmnopqrstuvwxyz*" ;
         System.out.println(t.makeStringByStringSet(t.getPinyin(str)));
     }

 }

这只是一个工具类，它使用到了PinyinHelper，PinyinHelper是加载字库文件用的，字库文件为/assets/unicode_to_hanyu_pinyin.txt，里面每一个汉字都对应着几个读音。

 package  com.ql.util;

 import  java.io.BufferedInputStream;
 import  java.io.FileNotFoundException;
 import  java.io.IOException;
 import  java.util.Properties;

 public   class  PinyinHelper{
     private   static  PinyinHelper instance;
     private  Properties properties =  null ;

     public   static  String[] getUnformattedHanyuPinyinStringArray( char  ch){
         return  getInstance().getHanyuPinyinStringArray(ch);
     }

     private  PinyinHelper(){
         initResource();
     }

     public   static  PinyinHelper getInstance(){
         if (instance== null ){
             instance = new  PinyinHelper();
         }
         return  instance;
     }

     private   void  initResource(){
         try {
             final  String resourceName =  "/assets/unicode_to_hanyu_pinyin.txt" ;
 //          final String resourceName = "/assets/unicode_py.ini";

             properties=new  Properties();
             properties.load(getResourceInputStream(resourceName));

         } catch  (FileNotFoundException ex){
             ex.printStackTrace();
         } catch  (IOException ex){
             ex.printStackTrace();
         }
     }

     private  BufferedInputStream getResourceInputStream(String resourceName){
         return   new  BufferedInputStream(PinyinHelper. class .getResourceAsStream(resourceName));
     }

     private  String[] getHanyuPinyinStringArray( char  ch){
         String pinyinRecord = getHanyuPinyinRecordFromChar(ch);

         if  ( null  != pinyinRecord){
             int  indexOfLeftBracket = pinyinRecord.indexOf(Field.LEFT_BRACKET);
             int  indexOfRightBracket = pinyinRecord.lastIndexOf(Field.RIGHT_BRACKET);

             String stripedString = pinyinRecord.substring(indexOfLeftBracket
                     + Field.LEFT_BRACKET.length(), indexOfRightBracket);

             return  stripedString.split(Field.COMMA);

         } else
             return   null ;

     }

     private  String getHanyuPinyinRecordFromChar( char  ch){
         int  codePointOfChar = ch;
         String codepointHexStr = Integer.toHexString(codePointOfChar).toUpperCase();
         String foundRecord = properties.getProperty(codepointHexStr);
         return  foundRecord;
     }

     class  Field{
         static   final  String LEFT_BRACKET =  "(" ;
         static   final  String RIGHT_BRACKET =  ")" ;
         static   final  String COMMA =  "," ;
     }

 }

至于解析字库，比如有一个汉字是这样的格式：4E01 (ding1,zheng1)，保存 到String[]当中就是{"ding1","zheng1"}这样的。但是这样的话到了PinYin4j中还需要使用substring(0,1)截 取首字母，效率有些低了，事实上文件中完全可以采用这样的格式存储：E01 (d,z)，直接存汉字的首字母就行了，这个另论！

最后，看看使用方法：

 public   class  QuickSearchActivity  extends  Activity {
     private   static   final  String tag= "QuickSearchActivity" ;
     private  AutoCompleteTextView search ;
     private  SlidingDrawer mDrawer;

     public  SearchAdapter adapter= null ; //
     //需要读取
     public  String[] hanzi =  new  String[] {
             "长江证券100002" , "长江证券100001" ,  "农业银行200001" , "工商银行300001"  ,
             "招商银行100001" ,  "建设银行100001" ,  "中国银行100002" ,  "华夏银行500002" ,
             "上海银行100010" ,  "浦发银行200009"
             };

     /** Called when the activity is first created. */
     @Override
     public   void  onCreate(Bundle savedInstanceState) {
         super .onCreate(savedInstanceState);
         setContentView(R.layout.main);

         initViews();
     }

     private   void  initViews(){
         search = (AutoCompleteTextView) findViewById(R.id.search);
         search.setOnItemClickListener(new  OnItemClickListener() {

             @Override
             public   void  onItemClick(AdapterView<?> arg0, View arg1,  int  position,
                     long  id) {
                 // TODO Auto-generated method stub
                 Log.d(tag, "onItemClick:" +position);
             }

         });

         search.setThreshold(1 );

         adapter = new  SearchAdapter<String>( this ,
                 android.R.layout.simple_dropdown_item_1line, hanzi,SearchAdapter.ALL);//速度优先
         search.setAdapter(adapter);//

         mDrawer = (SlidingDrawer) findViewById(R.id.slidingdrawer);

     }

 }

 

 

转自： http://gundumw100.iteye.com/blog/1331258

 

 

下载： dl.iteye.com/topics/download/bebae969-c880-37a0-9770-3a316438da81