JAVA获取字符串首字拼音和全拼

最新推荐文章于 2024-07-21 22:19:09 发布

罗小博

最新推荐文章于 2024-07-21 22:19:09 发布

阅读量858

点赞数 1

分类专栏： java 文章标签： java

java 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

转自：https://blog.csdn.net/KokJuis/article/details/53022302

JAVA获取字符串首字拼音或者全部拼音，用的是pinyin4j。

引入jar包：

<dependency>
   <groupId>pinyin4j</groupId>
   <artifactId>pinyin4j</artifactId>
   <version>2.5.1</version>
</dependency>

import java.util.ArrayList;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;

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 net.sourceforge.pinyin4j.format.exception.BadHanyuPinyinOutputFormatCombination;

public class Pinyin4jUtil {

   /**
   * 提取首个字符的首字母，其他返回*
   *
   * @param str
   * @return String
   */
   public static String getFirstPinYinHeadChar(String str) {

       StringBuffer pybf = new StringBuffer();
       char word = str.charAt(0);
       // 提取汉字的首字母
       String[] pinyinArray;
       // 是否是因为字母
       if (word > 128) {
           pinyinArray = PinyinHelper.toHanyuPinyinStringArray(word);
           // 如果不是汉字，就返回*
           if (pinyinArray != null) {
               pybf.append(pinyinArray[0].charAt(0));
           } else {
               pybf.append("*");
           }
       } else {

           // 是字母直接返回，不是返回*
           if (Character.isLetter(word)) {
               pybf.append(word);
           } else {
               pybf.append("*");
           }
       }

       // 全部返回大写
       return pybf.toString().toUpperCase();
   }

   /**
   * 将汉字转换为全拼
   *
   * @param src
   * @return String
   */
   public static String getPinYin(String src) {
       char[] t1 = null;
       t1 = src.toCharArray();
       // System.out.println(t1.length);
       String[] t2 = new String[t1.length];
       // System.out.println(t2.length);
       // 设置汉字拼音输出的格式
       HanyuPinyinOutputFormat t3 = new HanyuPinyinOutputFormat();
       t3.setCaseType(HanyuPinyinCaseType.LOWERCASE);
       t3.setToneType(HanyuPinyinToneType.WITHOUT_TONE);
       t3.setVCharType(HanyuPinyinVCharType.WITH_V);
       String t4 = "";
       int t0 = t1.length;
       try {
           for (int i = 0; i < t0; i++) {
               // 判断是否为汉字字符
               // System.out.println(t1[i]);
               if (Character.toString(t1[i]).matches("[\\u4E00-\\u9FA5]+")) {
                   t2 = PinyinHelper.toHanyuPinyinStringArray(t1[i], t3);// 将汉字的几种全拼都存到t2数组中
                   t4 += t2[0];// 取出该汉字全拼的第一种读音并连接到字符串t4后
               } else {
                   // 如果不是汉字字符，直接取出字符并连接到字符串t4后
                   t4 += Character.toString(t1[i]);
               }
           }
       } catch (BadHanyuPinyinOutputFormatCombination e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
       }
       return t4;
   }

   /**
   * 提取每个汉字的首字母
   *
   * @param str
   * @return String
   */
   public static String getPinYinHeadChar(String str) {
       String convert = "";
       for (int j = 0; j < str.length(); j++) {
           char word = str.charAt(j);
           // 提取汉字的首字母
           String[] pinyinArray = PinyinHelper.toHanyuPinyinStringArray(word);
           if (pinyinArray != null) {
               convert += pinyinArray[0].charAt(0);
           } else {
               convert += word;
           }
       }
       return convert;
   }

   /**
   * 将字符串转换成ASCII码
   *
   * @param cnStr
   * @return String
   */
   public static String getCnASCII(String cnStr) {
       StringBuffer strBuf = new StringBuffer();
       // 将字符串转换成字节序列
       byte[] bGBK = cnStr.getBytes();
       for (int i = 0; i < bGBK.length; i++) {
           // System.out.println(Integer.toHexString(bGBK[i] & 0xff));
           // 将每个字符转换成ASCII码
           strBuf.append(Integer.toHexString(bGBK[i] & 0xff) + " ");
       }
       return strBuf.toString();
   }

   /**
   * 汉字转换位汉语拼音首字母，英文字符不变，特殊字符丢失支持多音字，生成方式如（长沙市长:cssc,zssz,zssc,cssz）
   *
   * @param chines
   * 汉字
   * @return 拼音
   */
   public static String converterToFirstSpell(String chines) {
       StringBuffer pinyinName = new StringBuffer();
       char[] nameChar = chines.toCharArray();
       HanyuPinyinOutputFormat defaultFormat = new HanyuPinyinOutputFormat();
       defaultFormat.setCaseType(HanyuPinyinCaseType.LOWERCASE);
       defaultFormat.setToneType(HanyuPinyinToneType.WITHOUT_TONE);
       for (int i = 0; i < nameChar.length; i++) {
           if (nameChar[i] > 128) {
               try {
                   // 取得当前汉字的所有全拼
                   String[] strs = PinyinHelper.toHanyuPinyinStringArray(
                           nameChar[i], defaultFormat);
                   if (strs != null) {
                       for (int j = 0; j < strs.length; j++) {
                           // 取首字母
                           pinyinName.append(strs[j].charAt(0));
                           if (j != strs.length - 1) {
                               pinyinName.append(",");
                           }
                       }
                   }
                   // else {
                   // pinyinName.append(nameChar[i]);
                   // }
               } catch (BadHanyuPinyinOutputFormatCombination e) {
                   e.printStackTrace();
               }
           } else {
               pinyinName.append(nameChar[i]);
           }
           pinyinName.append(" ");
       }
       // return pinyinName.toString();
       return parseTheChineseByObject(discountTheChinese(pinyinName.toString()));
   }

   /**
   * 汉字转换位汉语全拼，英文字符不变，特殊字符丢失
   * 支持多音字，生成方式如（重当参:zhongdangcen,zhongdangcan,chongdangcen
   * ,chongdangshen,zhongdangshen,chongdangcan）
   *
   * @param chines
   * 汉字
   * @return 拼音
   */
   public static String converterToSpell(String chines) {
       StringBuffer pinyinName = new StringBuffer();
       char[] nameChar = chines.toCharArray();
       HanyuPinyinOutputFormat defaultFormat = new HanyuPinyinOutputFormat();
       defaultFormat.setCaseType(HanyuPinyinCaseType.LOWERCASE);
       defaultFormat.setToneType(HanyuPinyinToneType.WITHOUT_TONE);
       for (int i = 0; i < nameChar.length; i++) {
           if (nameChar[i] > 128) {
               try {
                   // 取得当前汉字的所有全拼
                   String[] strs = PinyinHelper.toHanyuPinyinStringArray(
                           nameChar[i], defaultFormat);
                   if (strs != null) {
                       for (int j = 0; j < strs.length; j++) {
                           pinyinName.append(strs[j]);
                           if (j != strs.length - 1) {
                               pinyinName.append(",");
                           }
                       }
                   }
               } catch (BadHanyuPinyinOutputFormatCombination e) {
                   e.printStackTrace();
               }
           } else {
               pinyinName.append(nameChar[i]);
           }
           pinyinName.append(" ");
       }
       // return pinyinName.toString();
       return parseTheChineseByObject(discountTheChinese(pinyinName.toString()));
   }

   /**
   * 去除多音字重复数据
   *
   * @param theStr
   * @return
   */
   private static List<Map<String, Integer>> discountTheChinese(String theStr) {
       // 去除重复拼音后的拼音列表
       List<Map<String, Integer>> mapList = new ArrayList<Map<String, Integer>>();
       // 用于处理每个字的多音字，去掉重复
       Map<String, Integer> onlyOne = null;
       String[] firsts = theStr.split(" ");
       // 读出每个汉字的拼音
       for (String str : firsts) {
           onlyOne = new Hashtable<String, Integer>();
           String[] china = str.split(",");
           // 多音字处理
           for (String s : china) {
               Integer count = onlyOne.get(s);
               if (count == null) {
                   onlyOne.put(s, new Integer(1));
               } else {
                   onlyOne.remove(s);
                   count++;
                   onlyOne.put(s, count);
               }
           }
           mapList.add(onlyOne);
       }
       return mapList;
   }

   /**
   * 解析并组合拼音，对象合并方案(推荐使用)
   *
   * @return
   */
   private static String parseTheChineseByObject(
           List<Map<String, Integer>> list) {
       Map<String, Integer> first = null; // 用于统计每一次,集合组合数据
       // 遍历每一组集合
       for (int i = 0; i < list.size(); i++) {
           // 每一组集合与上一次组合的Map
           Map<String, Integer> temp = new Hashtable<String, Integer>();
           // 第一次循环，first为空
           if (first != null) {
               // 取出上次组合与此次集合的字符，并保存
               for (String s : first.keySet()) {
                   for (String s1 : list.get(i).keySet()) {
                       String str = s + s1;
                       temp.put(str, 1);
                   }
               }
               // 清理上一次组合数据
               if (temp != null && temp.size() > 0) {
                   first.clear();
               }
           } else {
               for (String s : list.get(i).keySet()) {
                   String str = s;
                   temp.put(str, 1);
               }
           }
           // 保存组合数据以便下次循环使用
           if (temp != null && temp.size() > 0) {
               first = temp;
           }
       }
       String returnStr = "";
       if (first != null) {
           // 遍历取出组合字符串
           for (String str : first.keySet()) {
               returnStr += (str + ",");
           }
       }
       if (returnStr.length() > 0) {
           returnStr = returnStr.substring(0, returnStr.length() - 1);
       }
       return returnStr;
   }

}