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

柔情只为你懂 2022-07-15 05:15 156阅读 0赞

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

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;
    	}
    
    }

下面是使用到的jar包：

pinyin4j-2.5.0.jar

http://download.csdn.net/detail/kokjuis/9672141  [点击打开链接][Link 1]

[Link 1]: http://download.csdn.net/detail/kokjuis/9672141