中英文混合拼音排序(从首字母开始，相同则往下比较)

中英文混合拼音排序(从首字母开始，相同则往下比较)

中文/英文混合数据 进行转拼音(中文),按照26个字母顺序排序，从首字母开始比较，相同则比较第二个字母，如此类推，直到结束排序为止。

pom.xml添加依赖

<!-- https://mvnrepository.com/artifact/com.belerweb/pinyin4j -->
<dependency>
  <groupId>com.belerweb</groupId>
  <artifactId>pinyin4j</artifactId>
  <version>2.5.1</version>
</dependency>

代码如下：

package cn.com.rikylinz.util;

import com.alibaba.fastjson.JSON;
import net.sourceforge.pinyin4j.PinyinHelper;
import net.sourceforge.pinyin4j.format.HanyuPinyinCaseType;
import net.sourceforge.pinyin4j.format.HanyuPinyinOutputFormat;
import net.sourceforge.pinyin4j.format.HanyuPinyinToneType;
import net.sourceforge.pinyin4j.format.HanyuPinyinVCharType;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.List;

/**
 * 中英文混合 拼音排序
 * 排序规则：26个字母顺序排序，从首字母开始比较，相同则比较下一个字母
 * @author RiKylinz
 * @createDate 2021-02-26
 */
public class ChinaPinYinUtils {

    //日志打印类
    private static Logger logger = LoggerFactory.getLogger(ChinaPinYinUtils.class);

    private static ChinaPinYinUtils instance;

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

    /**
     * 汉字全拼
     * @param chinese   汉字/英文
     * @return
     */
    public String getPinyin(String chinese){
        char[] chars = chinese.toCharArray();
        //对输出的拼音设置
        HanyuPinyinOutputFormat pinYinType = new HanyuPinyinOutputFormat();
        pinYinType.setCaseType(HanyuPinyinCaseType.LOWERCASE);//小写
        pinYinType.setToneType(HanyuPinyinToneType.WITHOUT_TONE);//不带音标
        pinYinType.setVCharType(HanyuPinyinVCharType.WITH_V);//百度，本人也不知道

        String chinesePingyin = "";
        try {
            for (int i = 0; i < chars.length; i++) {
                //判断当前字符是否为汉字字符
                if(Character.toString(chars[i]).matches("[\\u4E00-\\u9FA5]+")){
                    //汉字
                    String[] array = PinyinHelper.toHanyuPinyinStringArray(chars[i], pinYinType);
                    chinesePingyin += array[0];
                }else{
                    //英文
                    chinesePingyin += Character.toString(chars[i]).toLowerCase();
                }
            }
        } catch (Exception e) {
            logger.info("汉字转全拼错误，错误原因:{}",e);
            e.printStackTrace();
        }
        return chinesePingyin;
    }

    /**
     * 汉字/英文混合数据 排序
     * 排序规则：字母按照26个字母顺序排序，出现相同，则判断下一个拼音字母
     * @param data  排序前的数据
     * @return  排序后的数据
     */
    public List<String> dataSort(List<String> data){
        System.out.println("排序前data = " + JSON.toJSONString(data));
        data.sort((x,y) -> this.compareTo(getPinyin(x),getPinyin(y)));
        System.out.println("排序后data = " + JSON.toJSONString(data));
        return data;
    }

    /**
     *比较方法
     * @param preString		第一个比较数据
     * @param suffString	第二个比较数据
     * @return preString {1:大于,0:等于,-1:小于} suffString
     */
    private int compareTo(String preString,String suffString){
        char[] preChars = preString.toCharArray();
        char[] suffChars = suffString.toCharArray();

        if(preChars.length < suffChars.length){
            for (int i = 0; i < preChars.length; i++) {
                //当前字符相等时，继续往下判断
                if((int)preChars[i] == (int)suffChars[i]){
                    //当前下标 是preChars最后下标，但不是suffChars的最后下标
                    if(i == preChars.length - 1 && i < suffChars.length - 1){
                        return -1;
                    }
                    continue;
                }else{
                    if((int)preChars[i] - (int)suffChars[i] > 0){
                        //小于
                        return -1;
                    }else{
                        //大于
                        return 1;
                    }
                }
            }
        }else{
            for (int i = 0; i < suffChars.length; i++) {
                //当前字符相等时，继续往下判断
                if((int)preChars[i] == (int)suffChars[i]){
                    //当前下标 是suffChars最后下标，但不是preChars的最后下标
                    if(i == suffChars.length - 1 && i < preChars.length - 1){
                        return 1;
                    }
                    continue;
                }else{
                    if((int)preChars[i] - (int)suffChars[i] > 0){
                        //小于
                        return -1;
                    }else{
                        //大于
                        return 1;
                    }
                }
            }
        }
        return 0;
    }
}