拼音操作工具类

拼音操作工具类，提供字符串转换成拼音数组、汉字转换成拼音、取汉字的首字母等方法。

源码如下：(点击下载 –PinyinUtil.java、pinyin4j-2.5.0.jar )

  1 import net.sourceforge.pinyin4j.PinyinHelper;
  2 import net.sourceforge.pinyin4j.format.HanyuPinyinCaseType;
  3 import net.sourceforge.pinyin4j.format.HanyuPinyinOutputFormat;
  4 import net.sourceforge.pinyin4j.format.HanyuPinyinToneType;
  5 import net.sourceforge.pinyin4j.format.exception.BadHanyuPinyinOutputFormatCombination;
  6 
  7 /**
  8  * 拼音操作工具类
  9  * 
 10  */
 11 public class PinyinUtil {
 12     /**
 13      * 将字符串转换成拼音数组
 14      * 
 15      * @param src
 16      * @return
 17      */
 18     public static String[] stringToPinyin(String src) {
 19         return stringToPinyin(src, false, null);
 20     }
 21 
 22     /**
 23      * 将字符串转换成拼音数组
 24      * 
 25      * @param src
 26      * @return
 27      */
 28     public static String[] stringToPinyin(String src, String separator) {
 29         return stringToPinyin(src, true, separator);
 30     }
 31 
 32     /**
 33      * 将字符串转换成拼音数组
 34      * 
 35      * @param src
 36      * @param isPolyphone
 37      *            是否查出多音字的所有拼音
 38      * @param separator
 39      *            多音字拼音之间的分隔符
 40      * @return
 41      */
 42     public static String[] stringToPinyin(String src, boolean isPolyphone,
 43             String separator) {
 44         // 判断字符串是否为空
 45         if ("".equals(src) || null == src) {
 46             return null;
 47         }
 48         char[] srcChar = src.toCharArray();
 49         int srcCount = srcChar.length;
 50         String[] srcStr = new String[srcCount];
 51 
 52         for (int i = 0; i < srcCount; i++) {
 53             srcStr[i] = charToPinyin(srcChar[i], isPolyphone, separator);
 54         }
 55         return srcStr;
 56     }
 57 
 58     /**
 59      * 将单个字符转换成拼音
 60      * 
 61      * @param src
 62      * @return
 63      */
 64     public static String charToPinyin(char src, boolean isPolyphone, String separator) {
 65         // 创建汉语拼音处理类
 66         HanyuPinyinOutputFormat defaultFormat = new HanyuPinyinOutputFormat();
 67         // 输出设置，大小写，音标方式
 68         defaultFormat.setCaseType(HanyuPinyinCaseType.LOWERCASE);
 69         defaultFormat.setToneType(HanyuPinyinToneType.WITHOUT_TONE);
 70 
 71         StringBuffer tempPinying = new StringBuffer();
 72 
 73         // 如果是中文
 74         if (src > 128) {
 75             try {
 76                 // 转换得出结果
 77                 String[] strs = PinyinHelper.toHanyuPinyinStringArray(src, defaultFormat);
 78 
 79                 // 是否查出多音字，默认是查出多音字的第一个字符
 80                 if (isPolyphone && null != separator) {
 81                     for (int i = 0; i < strs.length; i++) {
 82                         tempPinying.append(strs[i]);
 83                         if (strs.length != (i + 1)) {
 84                             // 多音字之间用特殊符号间隔起来
 85                             tempPinying.append(separator);
 86                         }
 87                     }
 88                 } else {
 89                     tempPinying.append(strs[0]);
 90                 }
 91 
 92             } catch (BadHanyuPinyinOutputFormatCombination e) {
 93                 e.printStackTrace();
 94             }
 95         } else {
 96             tempPinying.append(src);
 97         }
 98 
 99         return tempPinying.toString();
100 
101     }
102 
103     public static String hanziToPinyin(String hanzi) {
104         return hanziToPinyin(hanzi, " ");
105     }
106 
107     /**
108      * 将汉字转换成拼音
109      * 
110      * @param hanzi
111      * @param separator
112      * @return
113      */
114     @SuppressWarnings("deprecation")
115     public static String hanziToPinyin(String hanzi, String separator) {
116         // 创建汉语拼音处理类
117         HanyuPinyinOutputFormat defaultFormat = new HanyuPinyinOutputFormat();
118         // 输出设置，大小写，音标方式
119         defaultFormat.setCaseType(HanyuPinyinCaseType.LOWERCASE);
120         defaultFormat.setToneType(HanyuPinyinToneType.WITHOUT_TONE);
121 
122         String pinyingStr = "";
123         try {
124             pinyingStr = PinyinHelper.toHanyuPinyinString(hanzi, defaultFormat, separator);
125         } catch (BadHanyuPinyinOutputFormatCombination e) {
126             e.printStackTrace();
127         }
128         return pinyingStr;
129     }
130 
131     /**
132      * 将字符串数组转换成字符串
133      * 
134      * @param str
135      * @param separator
136      *            各个字符串之间的分隔符
137      * @return
138      */
139     public static String stringArrayToString(String[] str, String separator) {
140         StringBuffer sb = new StringBuffer();
141         for (int i = 0; i < str.length; i++) {
142             sb.append(str[i]);
143             if (str.length != (i + 1)) {
144                 sb.append(separator);
145             }
146         }
147         return sb.toString();
148     }
149 
150     /**
151      * 简单的将各个字符数组之间连接起来
152      * 
153      * @param str
154      * @return
155      */
156     public static String stringArrayToString(String[] str) {
157         return stringArrayToString(str, "");
158     }
159 
160     /**
161      * 将字符数组转换成字符串
162      * 
163      * @param str
164      * @param separator
165      *            各个字符串之间的分隔符
166      * @return
167      */
168     public static String charArrayToString(char[] ch, String separator) {
169         StringBuffer sb = new StringBuffer();
170         for (int i = 0; i < ch.length; i++) {
171             sb.append(ch[i]);
172             if (ch.length != (i + 1)) {
173                 sb.append(separator);
174             }
175         }
176         return sb.toString();
177     }
178 
179     /**
180      * 将字符数组转换成字符串
181      * 
182      * @param str
183      * @return
184      */
185     public static String charArrayToString(char[] ch) {
186         return charArrayToString(ch, " ");
187     }
188 
189     /**
190      * 取汉字的首字母
191      * 
192      * @param src
193      * @param isCapital
194      *            是否是大写
195      * @return
196      */
197     public static char[] getHeadByChar(char src, boolean isCapital) {
198         // 如果不是汉字直接返回
199         if (src <= 128) {
200             return new char[] { src };
201         }
202         // 获取所有的拼音
203         String[] pinyingStr = PinyinHelper.toHanyuPinyinStringArray(src);
204         // 过滤中文符号
205         if (pinyingStr == null) {
206             return new char[] { src };
207         }
208         // 创建返回对象
209         int polyphoneSize = pinyingStr.length;
210         char[] headChars = new char[polyphoneSize];
211         int i = 0;
212         // 截取首字符
213         for (String s : pinyingStr) {
214             char headChar = s.charAt(0);
215             // 首字母是否大写，默认是小写
216             if (isCapital) {
217                 headChars[i] = Character.toUpperCase(headChar);
218             } else {
219                 headChars[i] = headChar;
220             }
221             i++;
222         }
223 
224         return headChars;
225     }
226 
227     /**
228      * 取汉字的首字母(默认是大写)
229      * 
230      * @param src
231      * @return
232      */
233     public static char[] getHeadByChar(char src) {
234         return getHeadByChar(src, true);
235     }
236 
237     /**
238      * 查找字符串首字母
239      * 
240      * @param src
241      * @return
242      */
243     public static String[] getHeadByString(String src) {
244         return getHeadByString(src, true);
245     }
246 
247     /**
248      * 查找字符串首字母
249      * 
250      * @param src
251      * @param isCapital
252      *            是否大写
253      * @return
254      */
255     public static String[] getHeadByString(String src, boolean isCapital) {
256         return getHeadByString(src, isCapital, null);
257     }
258 
259     /**
260      * 查找字符串首字母
261      * 
262      * @param src
263      * @param isCapital
264      *            是否大写
265      * @param separator
266      *            分隔符
267      * @return
268      */
269     public static String[] getHeadByString(String src, boolean isCapital, String separator) {
270         char[] chars = src.toCharArray();
271         String[] headString = new String[chars.length];
272         int i = 0;
273         for (char ch : chars) {
274 
275             char[] chs = getHeadByChar(ch, isCapital);
276             StringBuffer sb = new StringBuffer();
277             if (null != separator) {
278                 int j = 1;
279 
280                 for (char ch1 : chs) {
281                     sb.append(ch1);
282                     if (j != chs.length) {
283                         sb.append(separator);
284                     }
285                     j++;
286                 }
287             } else {
288                 sb.append(chs[0]);
289             }
290             headString[i] = sb.toString();
291             i++;
292         }
293         return headString;
294     }
295 
296     public static String getPinyin(String hanzi) {
297         return stringArrayToString(stringToPinyin(hanzi));
298     }
299 }