实现城市列表的排序及模糊查询

作者 | wustor

地址 | https://www.jianshu.com/p/0ea45116f475

声明 | 本文是 wustor 原创，已获授权发布，未经原作者允许请勿转载

概述

项目需求中有一个需求，是用户输入的地址进行智能匹配，包含拼音匹配跟文字匹配，下面先展示一下需要实现的效果

其实看到这个需求，最开始的想法其实是很偷懒的，就是让服务端写一个接口，然后进行接口调用，不过在没网的时候就尴尬了，输入是没有提示的，所以这种方式其实不大好，再加上城市地址库一旦确定基本上就是不会轻易改变的，基于这几点考虑，打算做一个本地搜索。

正文

确定实现方式之后，其实思路就比较清晰了，首先请求一次接口的数据，然后直接放在本地，再加上项目的需求，所以基本的功能点如下：
主要有以下2点：

对接口返回的数据进行排序
根据排序进行分组
对用户的输入进行智能匹配

排序的实现

提到排序，其实首先会点到Java中的两个接口Comparable跟Comparator

Comparable

public interface Comparable<T> {    public int compareTo(T o);}

Comparable实际上就只是个接口，定义了一个compareTo方法，挺简单的，不过在使用的时候需要注意一下几点：

两个元素排序：需要实现compareTo方法，并且有一个int返回值，表明返回的结果，具体比较的规则可以根据需求自己定义，可以实现相同类型的参数进行比较.

多个元素排序：这里用地比较多的情况就是排序，JDK提供了一个工具类Arrays，调用Arrays.sort(Object[] a);只需要传入的数组实现了Comparable接口即可对传入的数组进行排序，这个时候我们注意到，Arrays.sort有很多重载方法，我们可以看一下

有很多我们熟悉的基本类型，int，byte，char，这些貌似跟Comparable没有什么关系，不过由于Java是面向对象的，所以对于基本类型有一个装箱拆箱操作，当看到基本类型的时候，应该多跟他们的包装类联系起来，那就随便找几个，int的包装类Integer进行byte的包装类Byte

public final class Integer extends Number implements Comparable<Integer>{      public int compareTo(Integer anotherInteger) {        return compare(this.value, anotherInteger.value);    }}public final class Byte extends Number implements Comparable<Byte>{      public int compareTo(Byte anotherByte) {        return compare(this.value, anotherByte.value);    }}public finalclass Character implements java.io.Serializable, Comparable<Character>{     public int compareTo(Character anotherCharacter) {        return compare(this.value, anotherCharacter.value);    }}

原来，他们的包装类都实现了Comparable接口，所以理清了，可以直接调用Arrays的sort方法对这些基本类型进行排序，当然，这里的排序都是基于包装类自身实现的排序算法，是固定不变的，如果是我们自定义的对象的话，需要重写compare方法。

Comparator

public interface Comparator<T> {    int compare(T o1, T o2);    boolean equals(Object obj);}

Comparator的方法比Comparable要多地多，这里选择了compare跟equals两个方法，compare很好理解，用来比较两个对象，equals是用来比较两个comparator的，如果传入的对象也是一个Comparator并且他们的排序规则也是一样的，则equals方法返回true，否则返回false.

两个元素：直接传入对象，即可比较
多个元素：Collections提供了sort方法，传入一个list，跟一个comparator

public static <T> void sort(List<T> list, Comparator<? super T> c) {        if (list.getClass() == ArrayList.class) {            Arrays.sort(((ArrayList) list).elementData, 0, list.size(), (Comparator) c);            return;        }        Object[] a = list.toArray();        Arrays.sort(a, (Comparator)c);        ListIterator<T> i = list.listIterator();        for (int j=0; j<a.length; j++) {            i.next();            i.set((T)a[j]);        }    }

然后方法里面还是调用了Arrays.sort，毕竟集合也是数组，最终还是调用了数组的排序方法。

对比分析

Comparator是在类的外部进行排序，Comparable是在类的内部进行排序

Comparator比较适合对于多个类进行排序，只需要实现一个Comparator就可以，Comparable则需要在每个类中实现Comparable接口

开始排序

排序通常的做法是对字母进行排序，但是接口返回的是文字，所以需要将文字转换成拼音，并且拿到首字母，才能进行排序，这里用到了一个第三方库TinyPinyin，适用于Java和Android的快速汉字转拼音库。

以武汉为例

用tinypinyin将所有的城市名称转换成拼音，用3个字段分别保存W,WH，WUHAN,其中W用来进行排序分组，WH是用来进行简拼匹配，WUHAN是用来进行全拼匹配
将城市列表的数据根据首字母安装ABCD的顺序进行排序，对于无法获取拼音的通过"#"进行标识
然后再进行二次分组，ABCD各位一大组，插入一个titleA,titleB,titleC，通过不同的type来在Recyclerview中进行type区分

这些其实没什么难度，下面贴一下Comparator的代码，自定义了compare方法，

@Override        public int compare(CityBean c1, CityBean c2) {            if (c1.getPinyinFirst().equals("#")) {                return 1;            } else if (c2.getPinyinFirst().equals("#")) {                return -1;            }            return c1.getPinyinFirst().compareTo(c2.getPinyinFirst());        }    }

查找算法

先定义一下查找规则

如果是汉字，则采用精准查找
如果是字母，当字母数量较小(3个以内)的时候，优先进行简拼，然后全拼，字母较多，使用全拼查找

正则匹配查找算法

public static void find(String inputStr, List<CityBean> old, List<CityBean> target) {        if (RegexUtils.isEnglishAlphabet(inputStr)) {            //拼音模糊匹配            findByEN(inputStr, old, target);        } else {            //含有中文精准匹配            findByCN(inputStr, old, target);        }    }

中文匹配

private static void findByCN(String inputStr, List<CityBean> mBodyDatas, List<CityBean> searchResult) {        for (int i = 0; i < mBodyDatas.size(); i++) {            CityBean cityBean = mBodyDatas.get(i);            if (!TextUtils.isEmpty(cityBean.getRegionName()) && cityBean.getRegionName().contains(inputStr)) {                searchResult.add(cityBean);            }        }    }

字母匹配

private static void findByEN(String inputStr, List<CityBean> mBodyDatas, List<CityBean> searchResult) {        //把输入的内容变为大写        String searPinyin = PinYinUtil.transformPinYin(inputStr);        //搜索字符串的长度        int searLength = searPinyin.length();        //搜索的第一个大写字母        for (int i = 0; i < mBodyDatas.size(); i++) {            CityBean cityBean = mBodyDatas.get(i);            //如果输入的每一个字母都和名字的首字母一样，那就可以匹配比如：武汉，WH            if (cityBean.getMatchPin().contains(searPinyin)) {                searchResult.add(cityBean);            } else {                boolean isMatch = false;                //先去匹配单个字，比如武汉WU,HAN.输入WU，肯定匹配第一个                for (int j = 0; j < cityBean.getNamePinyinList().size(); j++) {                    String namePinyinPer = cityBean.getNamePinyinList().get(j);                    if (!TextUtils.isEmpty(namePinyinPer) && namePinyinPer.startsWith(searPinyin)) {                        //符合的话就是当前字匹配成功                        searchResult.add(cityBean);                        isMatch = true;                        break;                    }                }                if (isMatch) {                    continue;                }//                根据拼音包含来实现，比如武汉：WUHAN,输入WUHA或者WUHAN。                if (!TextUtils.isEmpty(cityBean.getNamePinYin()) && cityBean.getNamePinYin().contains(searPinyin)) {                    //这样的话就要从每个字的拼音开始匹配起                    for (int j = 0; j < cityBean.getNamePinyinList().size(); j++) {                        StringBuilder sbMatch = new StringBuilder();                        for (int k = j; k < cityBean.getNamePinyinList().size(); k++) {                            sbMatch.append(cityBean.getNamePinyinList().get(k));                        }                        if (sbMatch.toString().startsWith(searPinyin)) {                            //匹配成功                            int length = 0;                            //比如输入是WUH，或者WUHA,或者WUHAN,这些都可以匹配上                            for (int k = j; k < cityBean.getNamePinyinList().size(); k++) {                                length = length + cityBean.getNamePinyinList().get(k).length();                                if (length >= searLength) {                                    break;                                }                            }                            //有可能重复匹配                            if (!searchResult.contains(cityBean))                                searchResult.add(cityBean);                        }                    }                }            }        }    }

由于我是在内存中进行匹配查找的，这样虽然效率比较高，但是进行匹配的时候，过多地使用了for循环，整体的性能不是很好，后续会尝试着通过Sqlite进行查找，这样的话，效率可能会高一下，感兴趣的可以优化一下。

源码下载

https://github.com/wustor/Localsearchdemo

与之相关

2017 | 我在 5 个月时间里分享了 98 篇文章