1. <dependency>
    2.     <groupId>com.belerweb</groupId>
    3.     <artifactId>pinyin4j</artifactId>
    4.     <version>2.5.0</version>
    5.  </dependency>
    1. package com.infinitePossibilities.utils;
    3. import java.util.Arrays;
    4. import java.util.HashSet;
    5. import java.util.Set;
    6. import net.sourceforge.pinyin4j.PinyinHelper;
    7. import net.sourceforge.pinyin4j.format.HanyuPinyinCaseType;
    8. import net.sourceforge.pinyin4j.format.HanyuPinyinOutputFormat;
    9. import net.sourceforge.pinyin4j.format.HanyuPinyinToneType;
    10. import net.sourceforge.pinyin4j.format.HanyuPinyinVCharType;
    11. import net.sourceforge.pinyin4j.format.exception.BadHanyuPinyinOutputFormatCombination;
    12. import wfc.service.log.Log;
    14. public class pinYinUtils {
    16.     public static int wordLength = 20;
    17.         /**
    18.          * 将字符串中的中文转化为拼音,其他字符不变
    19.          *
    20.          * @param inputString
    21.          * @return
    22.          */
    23.         public static String getPingYin(String inputString,int type) {
    24.             HanyuPinyinOutputFormat format = new HanyuPinyinOutputFormat();
    25.             //大小写
    26.             if(1 == type){
    27.                 format.setCaseType(HanyuPinyinCaseType.LOWERCASE);
    28.             }else{
    29.                 format.setCaseType(HanyuPinyinCaseType.UPPERCASE);
    30.             }
    31.             format.setToneType(HanyuPinyinToneType.WITHOUT_TONE);
    32.             format.setVCharType(HanyuPinyinVCharType.WITH_V);
    34.             char[] input = inputString.trim().toCharArray();
    35.             String output = "";
    37.             try {
    38.                 for (int i = 0; i < input.length; i++) {
    39.                     if (Character.toString(input[i]).matches("[\\u4E00-\\u9FA5]+")) {
    40.                         String[] temp = PinyinHelper.toHanyuPinyinStringArray(input[i], format);
    41.                         output += temp[0];
    42.                     } else {
    43.                         output += Character.toString(input[i]);
    44.                     }
    45.                 }
    46.             } catch (BadHanyuPinyinOutputFormatCombination e) {
    47.                 e.printStackTrace();
    48.             }
    49.             return output;
    50.         }
    52.         /**
    53.          * 获取汉字串拼音首字母，英文字符不变
    54.          * @param chinese 汉字串
    55.          * @return 汉语拼音首字母
    56.          */
    57.         public static String getFirstSpell(String chinese,int type) {
    58.                 StringBuffer pybf = new StringBuffer();
    59.                 char[] arr = chinese.toCharArray();
    60.                 HanyuPinyinOutputFormat defaultFormat = new HanyuPinyinOutputFormat();
    61.                 //大小写
    62.                 if(1 == type){
    63.                     defaultFormat.setCaseType(HanyuPinyinCaseType.LOWERCASE);
    64.                 }else{
    65.                     defaultFormat.setCaseType(HanyuPinyinCaseType.UPPERCASE);
    66.                 }
    67.                 defaultFormat.setToneType(HanyuPinyinToneType.WITHOUT_TONE);
    68.                 for (int i = 0; i < arr.length; i++) {
    69.                         if (arr[i] > 128) {
    70.                                 try {
    71.                                         String[] temp = PinyinHelper.toHanyuPinyinStringArray(arr[i], defaultFormat);
    72.                                         if (temp != null) {
    73.                                                 pybf.append(temp[0].charAt(0));
    74.                                         }
    75.                                 } catch (BadHanyuPinyinOutputFormatCombination e) {
    76.                                         e.printStackTrace();
    77.                                 }
    78.                         } else {
    79.                                 pybf.append(arr[i]);
    80.                         }
    81.                 }
    82.                 return pybf.toString().replaceAll("\\W", "").trim();
    83.         }
    87.         /**
    88.          * 获取拼音集合
    89.          *
    90.          * @param src
    91.          * @return Set<String>
    92.          */
    93.         public static Set<String> getPinyin(String src) {
    94.             if (src != null && !src.trim().equalsIgnoreCase("")) {
    95.                 char[] srcChar;
    96.                 srcChar = src.toCharArray();
    97.                 // 汉语拼音格式输出类
    98.                 HanyuPinyinOutputFormat hanYuPinOutputFormat = new HanyuPinyinOutputFormat();
    100.                 // 输出设置，大小写，音标方式等
    101.                 hanYuPinOutputFormat.setCaseType(HanyuPinyinCaseType.LOWERCASE);
    102.                 hanYuPinOutputFormat.setToneType(HanyuPinyinToneType.WITHOUT_TONE);
    103.                 hanYuPinOutputFormat.setVCharType(HanyuPinyinVCharType.WITH_V);
    104.                 // 因为多音字问题，导致在Exchange方法中排序组合后内存溢出，所以根据使用习惯或者查询喜欢，只取前几个文字，解决内存溢出问题
    105.                 if (src.length() <= wordLength) {
    106.                     wordLength = src.length();
    107.                 }
    108.                 String[][] temp = new String[wordLength][];
    109.                 for (int i = 0; i < wordLength; i++) {
    110.                     char c = srcChar[i];
    111.                     // 是中文或者a-z或者A-Z转换拼音(我的需求，是保留中文或者a-z或者A-Z)
    112.                     if (String.valueOf(c).matches("[\\u4E00-\\u9FA5]+")) {
    113.                         try {
    114.                             temp[i] = PinyinHelper.toHanyuPinyinStringArray(
    115.                                     srcChar[i], hanYuPinOutputFormat);
    116.                         } catch (BadHanyuPinyinOutputFormatCombination e) {
    117.                             e.printStackTrace();
    118.                         }
    120.                     } else if (((int) c >= 65 && (int) c <= 90) || ((int) c >= 97 && (int) c <= 122)) {
    121.                         temp[i] = new String[] { String.valueOf(srcChar[i]) };
    122.                     } else {
    123.                         temp[i] = new String[] { "" };
    124.                     }
    125.                 }
    126.                 System.out.println(Arrays.toString(temp));
    127.                 String[] pingyinArray = Exchange(temp);
    128.                 Set<String> pinyinSet = new HashSet<String>();
    129.                 for (int i = 0; i < pingyinArray.length; i++) {
    130.                     pinyinSet.add(pingyinArray[i]);
    131.                 }
    132.                 return pinyinSet;
    133.             }
    134.             Log.info("参数校验不合法！");
    135.             return new HashSet<String>();
    136.         }
    140.     public static void main(String[] args) {
    142.         System.out.println(getPingYin("将字符串中的中文转化为拼音,其他字符不变",1));
    143.         System.out.println(getFirstSpell("获取汉字串拼音首字母，英文字符不变",1));
    144.         System.out.println(getPinyin("获取拼音集合11测试cc"));
    145.     }
    148.     /**
    149.      * 递归
    150.      *
    151.      * @param strJaggedArray
    152.      * @return
    153.      */
    154.     public static String[] Exchange(String[][] strJaggedArray) {
    155.         String[][] temp = DoExchange(strJaggedArray);
    156.         System.out.println("---:"+ Arrays.toString(temp));
    157.         return temp[0];
    158.     }
    160.     /**
    161.      * 递归
    162.      *
    163.      * @param strJaggedArray
    164.      * @return
    165.      */
    166.     private static String[][] DoExchange(String[][] strJaggedArray) {
    167.         int len = strJaggedArray.length;
    168.         if (len >= 2) {
    169.             int len1 = strJaggedArray[0].length;
    170.             int len2 = strJaggedArray[1].length;
    171.             int newlen = len1 * len2;
    172.             String[] temp = new String[newlen];
    173.             int Index = 0;
    174.             for (int i = 0; i < len1; i++) {
    175.                 for (int j = 0; j < len2; j++) {
    176.                     temp[Index] = strJaggedArray[0][i] + strJaggedArray[1][j];
    177.                     Index++;
    178.                 }
    179.             }
    180.             String[][] newArray = new String[len - 1][];
    181.             for (int i = 2; i < len; i++) {
    182.                 newArray[i - 1] = strJaggedArray[i];
    183.             }
    184.             newArray[0] = temp;
    185.             return DoExchange(newArray);
    186.         } else {
    187.             return strJaggedArray;
    188.         }
    189.     }
    192. }