【JAVA】根据汉字拼音首字母排序 不同类型处理

分页列表中进行排序

个人对Page分页的理解
首先是sql那边拿到列表数据（当前项目中是根据创建时间排序的）
然后每次currentPageNo更改，都会按照列表的数据取出一部分显示
如果取出后再进行排序，那只有当前页面是按拼音排序，做不到整理列表是按拼音排序的。
所以思路是获取列表数据后，整个先按拼音排序后，再加分页到前端显示

    @Override
    public Page<StarBankSupportDTO> queryBankList(Page<StarBankSupportDTO> page, StarBankSupportDTO dto) {
    	//获取List数据
        List<StarBankSupportDTO> orderList = this.starBankSupportDao.queryBankSupportList(dto);
        //按拼音首字母排序
        StarBankSupportDTO[] starBankSupportArr = new StarBankSupportDTO[orderList.size()];
        orderList = Arrays.asList(orderList.toArray(starBankSupportArr));
        Arrays.sort(orderList.toArray(starBankSupportArr), new PinyinStarBankComparator());
        //List加分页
        List<StarBankSupportDTO> newList=null;
        int total=orderList.size();
        int rows = page.getPageSize();
        int pageNo = page.getCurrentPageNo();
        if(pageNo<1){
            pageNo = 1;
        }
        newList=orderList.subList(rows*(pageNo-1)>total?total:rows*(pageNo-1), ((rows*pageNo)>total?total:(rows*pageNo)));
		//返回Page对象
        return new Page<StarBankSupportDTO>(page, orderList.size(), newList);
    }

	//汉字按照拼音排序的比较器
    public class PinyinStarBankComparator implements Comparator<Object> {
        public int compare(Object o1, Object o2) {
        	//根据Dto的bankName的拼音首字母排序
            char c1 = ((StarBankSupportDTO) o1).getBankName().charAt(0);
            char c2 = ((StarBankSupportDTO) o2).getBankName().charAt(0);
            return concatPinyinStringArray(
                    PinyinHelper.toHanyuPinyinStringArray(c1)).compareTo(
                    concatPinyinStringArray(PinyinHelper
                            .toHanyuPinyinStringArray(c2)));
        }
        private String concatPinyinStringArray(String[] pinyinArray) {
            StringBuffer pinyinSbf = new StringBuffer();
            if ((pinyinArray != null) && (pinyinArray.length > 0)) {
                for (int i = 0; i < pinyinArray.length; i++) {
                	//对重庆的读音特殊处理
                    if("zhong4".equals(pinyinArray[i]) || "chong2".equals(pinyinArray[i])){
                        Arrays.sort(pinyinArray,String.CASE_INSENSITIVE_ORDER);
                    }
                    pinyinSbf.append(pinyinArray[i]);
                }
            }
            return pinyinSbf.toString();
        }
    }

ArrayList中进行排序

将ArrayList 转换成List排序后，将原来的List清空，再将排序后的ArrayList添加到原List中

provinceMap.forEach((item, value) -> {
    ConcurrentHashMap<String, ArrayList> province = new ConcurrentHashMap<>();
    ConcurrentHashMap<String, ArrayList> city = value.get(item);
    ArrayList cityList = new ArrayList();
    city.forEach((item2, value2) -> {
        if (value2.size() > 0) {
            ConcurrentHashMap<String, ArrayList> area = new ConcurrentHashMap<>();
            area.put(item2, value2);
            cityList.add(area);
        } else {
            cityList.add(item2);
        }
    });
    
    //按拼音首字母排序方法
    String[] objects = new String[cityList.size()];
    //将ArrayList转换成List
    List citySortlist = Arrays.asList(cityList.toArray(objects));
    Arrays.sort(cityList.toArray(objects), new PinyinStrComparator());
    //将原来的List清空
    cityList.clear();
    //将排序后的ArrayList添加到原List中
    cityList.addAll(citySortlist);
    province.put(item, cityList);
    data.add(province);
});

//汉字按照拼音排序的比较器
public class PinyinStrComparator implements Comparator<Object> {
    public int compare(Object o1, Object o2) {
    	//字符串第一个字符排序
        char c1 = ((String) o1).charAt(0);
        char c2 = ((String) o2).charAt(0);
        return concatPinyinStringArray(
                PinyinHelper.toHanyuPinyinStringArray(c1)).compareTo(
                concatPinyinStringArray(PinyinHelper
                        .toHanyuPinyinStringArray(c2)));
    }
    private String concatPinyinStringArray(String[] pinyinArray) {
        StringBuffer pinyinSbf = new StringBuffer();
        if ((pinyinArray != null) && (pinyinArray.length > 0)) {
            for (int i = 0; i < pinyinArray.length; i++) {
                if("zhong4".equals(pinyinArray[i]) || "chong2".equals(pinyinArray[i])){
                    Arrays.sort(pinyinArray,String.CASE_INSENSITIVE_ORDER);
                }
                pinyinSbf.append(pinyinArray[i]);
            }
        }
        return pinyinSbf.toString();
    }
}

Map的键排序

public ResultDto getAreaList(String channelId, String areaType) {
    List<Object> list = this.planService.getAreaListByChannel(channelId, areaType);
	//排序开始
    Object[] objects = new Object[list.size()];
    list = Arrays.asList(list.toArray(objects));
    Arrays.sort(list.toArray(objects), new PinyinMapComparator());
    return ResultDto.success(list);
}

//汉字按照拼音排序的比较器
public class PinyinMapComparator implements Comparator<Object> {
    public int compare(Object o1, Object o2) {
    	//获取键的首个字符
    	//这里键限定为String
    	//注意这里获取键的写法
        char c1 = ((ConcurrentHashMap) o1).keys().nextElement().toString().charAt(0);
        char c2 = ((ConcurrentHashMap) o2).keys().nextElement().toString().charAt(0);
        return concatPinyinStringArray(
                PinyinHelper.toHanyuPinyinStringArray(c1)).compareTo(
                concatPinyinStringArray(PinyinHelper
                        .toHanyuPinyinStringArray(c2)));
    }
    private String concatPinyinStringArray(String[] pinyinArray) {
        StringBuffer pinyinSbf = new StringBuffer();
        if ((pinyinArray != null) && (pinyinArray.length > 0)) {
            for (int i = 0; i < pinyinArray.length; i++) {
                if("zhong4".equals(pinyinArray[i]) || "chong2".equals(pinyinArray[i])){
                    Arrays.sort(pinyinArray,String.CASE_INSENSITIVE_ORDER);
                }
                pinyinSbf.append(pinyinArray[i]);
            }
        }
        return pinyinSbf.toString();
    }
}

String数组排序

public void test_sort_pinyin2() {  
    String[] arr = { "张三", "李四", "王五", "赵六",  "哈哈" };  
    List<String> list = Arrays.asList(arr);  
    //arr是数据源
    Arrays.sort(arr, new PinyinComparator());  
    System.out.println(list);  
} 
    
//汉字按照拼音排序的比较器
public class PinyinComparator implements Comparator<Object> {  
    public int compare(Object o1, Object o2) {  
        char c1 = ((String) o1).charAt(0);  
        char c2 = ((String) o2).charAt(0);  
        return concatPinyinStringArray(  
                PinyinHelper.toHanyuPinyinStringArray(c1)).compareTo(  
                concatPinyinStringArray(PinyinHelper  
                        .toHanyuPinyinStringArray(c2)));  
    }  
    private String concatPinyinStringArray(String[] pinyinArray) {  
        StringBuffer pinyinSbf = new StringBuffer();  
        if ((pinyinArray != null) && (pinyinArray.length > 0)) {  
            for (int i = 0; i < pinyinArray.length; i++) {  
                pinyinSbf.append(pinyinArray[i]);  
            }  
        }  
        return pinyinSbf.toString();  
    }  
}