Java获取汉字拼音

为了配合模糊查询 很多情况下 我们需要用到汉字首字母 进行模糊查询， 这样的例子很多， 做法也很多，有的是写在数据库中，有的是写在java程序中

 

java程序中有

1.

Java代码  

1. package com.zkq.framework.util;  
2.   
3. /**   
4.  * @explain:  
5.  
6.  * @author: zkq   
7.  
8.  * @createtime: 2009-12-13 上午09:25:16   
9.  
10.  * @version:   
11.  
12.  */  
13.   
14. //Java实现汉字转换为拼音  
15. import java.util.Iterator;  
16. import java.util.LinkedHashMap;  
17. import java.util.Set;  
18.   
19. /** 
20.  *  
21.  * 汉字转化为全拼 
22.  *  
23.  * JDK版本: 1.6 
24.  */  
25. public class CnToSpell {  
26.   
27.     private static LinkedHashMap spellMap = null;  
28.   
29.     static {  
30.         if (spellMap == null) {  
31.             spellMap = new LinkedHashMap(400);  
32.         }  
33.         initialize();  
34.         // System.out.println("Chinese transfer Spell Done.");  
35.     }  
36.   
37.     private CnToSpell() {  
38.     }  
39.   
40.     private static void spellPut(String spell, int ascii) {  
41.         spellMap.put(spell, new Integer(ascii));  
42.     }  
43.   
44.     private static void initialize() {  
45.         spellPut("a", -20319);  
46.         spellPut("ai", -20317);  
47.         spellPut("an", -20304);  
48.         spellPut("ang", -20295);  
49.         spellPut("ao", -20292);  
50.         spellPut("ba", -20283);  
51.         spellPut("bai", -20265);  
52.         spellPut("ban", -20257);  
53.         spellPut("bang", -20242);  
54.         spellPut("bao", -20230);  
55.         spellPut("bei", -20051);  
56.         spellPut("ben", -20036);  
57.         spellPut("beng", -20032);  
58.         spellPut("bi", -20026);  
59.         spellPut("bian", -20002);  
60.         spellPut("biao", -19990);  
61.         spellPut("bie", -19986);  
62.         spellPut("bin", -19982);  
63.         spellPut("bing", -19976);  
64.         spellPut("bo", -19805);  
65.         spellPut("bu", -19784);  
66.         spellPut("ca", -19775);  
67.         spellPut("cai", -19774);  
68.         spellPut("can", -19763);  
69.         spellPut("cang", -19756);  
70.         spellPut("cao", -19751);  
71.         spellPut("ce", -19746);  
72.         spellPut("ceng", -19741);  
73.         spellPut("cha", -19739);  
74.         spellPut("chai", -19728);  
75.         spellPut("chan", -19725);  
76.         spellPut("chang", -19715);  
77.         spellPut("chao", -19540);  
78.         spellPut("che", -19531);  
79.         spellPut("chen", -19525);  
80.         spellPut("cheng", -19515);  
81.         spellPut("chi", -19500);  
82.         spellPut("chong", -19484);  
83.         spellPut("chou", -19479);  
84.         spellPut("chu", -19467);  
85.         spellPut("chuai", -19289);  
86.         spellPut("chuan", -19288);  
87.         spellPut("chuang", -19281);  
88.         spellPut("chui", -19275);  
89.         spellPut("chun", -19270);  
90.         spellPut("chuo", -19263);  
91.         spellPut("ci", -19261);  
92.         spellPut("cong", -19249);  
93.         spellPut("cou", -19243);  
94.         spellPut("cu", -19242);  
95.         spellPut("cuan", -19238);  
96.         spellPut("cui", -19235);  
97.         spellPut("cun", -19227);  
98.         spellPut("cuo", -19224);  
99.         spellPut("da", -19218);  
100.         spellPut("dai", -19212);  
101.         spellPut("dan", -19038);  
102.         spellPut("dang", -19023);  
103.         spellPut("dao", -19018);  
104.         spellPut("de", -19006);  
105.         spellPut("deng", -19003);  
106.         spellPut("di", -18996);  
107.         spellPut("dian", -18977);  
108.         spellPut("diao", -18961);  
109.         spellPut("die", -18952);  
110.         spellPut("ding", -18783);  
111.         spellPut("diu", -18774);  
112.         spellPut("dong", -18773);  
113.         spellPut("dou", -18763);  
114.         spellPut("du", -18756);  
115.         spellPut("duan", -18741);  
116.         spellPut("dui", -18735);  
117.         spellPut("dun", -18731);  
118.         spellPut("duo", -18722);  
119.         spellPut("e", -18710);  
120.         spellPut("en", -18697);  
121.         spellPut("er", -18696);  
122.         spellPut("fa", -18526);  
123.         spellPut("fan", -18518);  
124.         spellPut("fang", -18501);  
125.         spellPut("fei", -18490);  
126.         spellPut("fen", -18478);  
127.         spellPut("feng", -18463);  
128.         spellPut("fo", -18448);  
129.         spellPut("fou", -18447);  
130.         spellPut("fu", -18446);  
131.         spellPut("ga", -18239);  
132.         spellPut("gai", -18237);  
133.         spellPut("gan", -18231);  
134.         spellPut("gang", -18220);  
135.         spellPut("gao", -18211);  
136.         spellPut("ge", -18201);  
137.         spellPut("gei", -18184);  
138.         spellPut("gen", -18183);  
139.         spellPut("geng", -18181);  
140.         spellPut("gong", -18012);  
141.         spellPut("gou", -17997);  
142.         spellPut("gu", -17988);  
143.         spellPut("gua", -17970);  
144.         spellPut("guai", -17964);  
145.         spellPut("guan", -17961);  
146.         spellPut("guang", -17950);  
147.         spellPut("gui", -17947);  
148.         spellPut("gun", -17931);  
149.         spellPut("guo", -17928);  
150.         spellPut("ha", -17922);  
151.         spellPut("hai", -17759);  
152.         spellPut("han", -17752);  
153.         spellPut("hang", -17733);  
154.         spellPut("hao", -17730);  
155.         spellPut("he", -17721);  
156.         spellPut("hei", -17703);  
157.         spellPut("hen", -17701);  
158.         spellPut("heng", -17697);  
159.         spellPut("hong", -17692);  
160.         spellPut("hou", -17683);  
161.         spellPut("hu", -17676);  
162.         spellPut("hua", -17496);  
163.         spellPut("huai", -17487);  
164.         spellPut("huan", -17482);  
165.         spellPut("huang", -17468);  
166.         spellPut("hui", -17454);  
167.         spellPut("hun", -17433);  
168.         spellPut("huo", -17427);  
169.         spellPut("ji", -17417);  
170.         spellPut("jia", -17202);  
171.         spellPut("jian", -17185);  
172.         spellPut("jiang", -16983);  
173.         spellPut("jiao", -16970);  
174.         spellPut("jie", -16942);  
175.         spellPut("jin", -16915);  
176.         spellPut("jing", -16733);  
177.         spellPut("jiong", -16708);  
178.         spellPut("jiu", -16706);  
179.         spellPut("ju", -16689);  
180.         spellPut("juan", -16664);  
181.         spellPut("jue", -16657);  
182.         spellPut("jun", -16647);  
183.         spellPut("ka", -16474);  
184.         spellPut("kai", -16470);  
185.         spellPut("kan", -16465);  
186.         spellPut("kang", -16459);  
187.         spellPut("kao", -16452);  
188.         spellPut("ke", -16448);  
189.         spellPut("ken", -16433);  
190.         spellPut("keng", -16429);  
191.         spellPut("kong", -16427);  
192.         spellPut("kou", -16423);  
193.         spellPut("ku", -16419);  
194.         spellPut("kua", -16412);  
195.         spellPut("kuai", -16407);  
196.         spellPut("kuan", -16403);  
197.         spellPut("kuang", -16401);  
198.         spellPut("kui", -16393);  
199.         spellPut("kun", -16220);  
200.         spellPut("kuo", -16216);  
201.         spellPut("la", -16212);  
202.         spellPut("lai", -16205);  
203.         spellPut("lan", -16202);  
204.         spellPut("lang", -16187);  
205.         spellPut("lao", -16180);  
206.         spellPut("le", -16171);  
207.         spellPut("lei", -16169);  
208.         spellPut("leng", -16158);  
209.         spellPut("li", -16155);  
210.         spellPut("lia", -15959);  
211.         spellPut("lian", -15958);  
212.         spellPut("liang", -15944);  
213.         spellPut("liao", -15933);  
214.         spellPut("lie", -15920);  
215.         spellPut("lin", -15915);  
216.         spellPut("ling", -15903);  
217.         spellPut("liu", -15889);  
218.         spellPut("long", -15878);  
219.         spellPut("lou", -15707);  
220.         spellPut("lu", -15701);  
221.         spellPut("lv", -15681);  
222.         spellPut("luan", -15667);  
223.         spellPut("lue", -15661);  
224.         spellPut("lun", -15659);  
225.         spellPut("luo", -15652);  
226.         spellPut("ma", -15640);  
227.         spellPut("mai", -15631);  
228.         spellPut("man", -15625);  
229.         spellPut("mang", -15454);  
230.         spellPut("mao", -15448);  
231.         spellPut("me", -15436);  
232.         spellPut("mei", -15435);  
233.         spellPut("men", -15419);  
234.         spellPut("meng", -15416);  
235.         spellPut("mi", -15408);  
236.         spellPut("mian", -15394);  
237.         spellPut("miao", -15385);  
238.         spellPut("mie", -15377);  
239.         spellPut("min", -15375);  
240.         spellPut("ming", -15369);  
241.         spellPut("miu", -15363);  
242.         spellPut("mo", -15362);  
243.         spellPut("mou", -15183);  
244.         spellPut("mu", -15180);  
245.         spellPut("na", -15165);  
246.         spellPut("nai", -15158);  
247.         spellPut("nan", -15153);  
248.         spellPut("nang", -15150);  
249.         spellPut("nao", -15149);  
250.         spellPut("ne", -15144);  
251.         spellPut("nei", -15143);  
252.         spellPut("nen", -15141);  
253.         spellPut("neng", -15140);  
254.         spellPut("ni", -15139);  
255.         spellPut("nian", -15128);  
256.         spellPut("niang", -15121);  
257.         spellPut("niao", -15119);  
258.         spellPut("nie", -15117);  
259.         spellPut("nin", -15110);  
260.         spellPut("ning", -15109);  
261.         spellPut("niu", -14941);  
262.         spellPut("nong", -14937);  
263.         spellPut("nu", -14933);  
264.         spellPut("nv", -14930);  
265.         spellPut("nuan", -14929);  
266.         spellPut("nue", -14928);  
267.         spellPut("nuo", -14926);  
268.         spellPut("o", -14922);  
269.         spellPut("ou", -14921);  
270.         spellPut("pa", -14914);  
271.         spellPut("pai", -14908);  
272.         spellPut("pan", -14902);  
273.         spellPut("pang", -14894);  
274.         spellPut("pao", -14889);  
275.         spellPut("pei", -14882);  
276.         spellPut("pen", -14873);  
277.         spellPut("peng", -14871);  
278.         spellPut("pi", -14857);  
279.         spellPut("pian", -14678);  
280.         spellPut("piao", -14674);  
281.         spellPut("pie", -14670);  
282.         spellPut("pin", -14668);  
283.         spellPut("ping", -14663);  
284.         spellPut("po", -14654);  
285.         spellPut("pu", -14645);  
286.         spellPut("qi", -14630);  
287.         spellPut("qia", -14594);  
288.         spellPut("qian", -14429);  
289.         spellPut("qiang", -14407);  
290.         spellPut("qiao", -14399);  
291.         spellPut("qie", -14384);  
292.         spellPut("qin", -14379);  
293.         spellPut("qing", -14368);  
294.         spellPut("qiong", -14355);  
295.         spellPut("qiu", -14353);  
296.         spellPut("qu", -14345);  
297.         spellPut("quan", -14170);  
298.         spellPut("que", -14159);  
299.         spellPut("qun", -14151);  
300.         spellPut("ran", -14149);  
301.         spellPut("rang", -14145);  
302.         spellPut("rao", -14140);  
303.         spellPut("re", -14137);  
304.         spellPut("ren", -14135);  
305.         spellPut("reng", -14125);  
306.         spellPut("ri", -14123);  
307.         spellPut("rong", -14122);  
308.         spellPut("rou", -14112);  
309.         spellPut("ru", -14109);  
310.         spellPut("ruan", -14099);  
311.         spellPut("rui", -14097);  
312.         spellPut("run", -14094);  
313.         spellPut("ruo", -14092);  
314.         spellPut("sa", -14090);  
315.         spellPut("sai", -14087);  
316.         spellPut("san", -14083);  
317.         spellPut("sang", -13917);  
318.         spellPut("sao", -13914);  
319.         spellPut("se", -13910);  
320.         spellPut("sen", -13907);  
321.         spellPut("seng", -13906);  
322.         spellPut("sha", -13905);  
323.         spellPut("shai", -13896);  
324.         spellPut("shan", -13894);  
325.         spellPut("shang", -13878);  
326.         spellPut("shao", -13870);  
327.         spellPut("she", -13859);  
328.         spellPut("shen", -13847);  
329.         spellPut("sheng", -13831);  
330.         spellPut("shi", -13658);  
331.         spellPut("shou", -13611);  
332.         spellPut("shu", -13601);  
333.         spellPut("shua", -13406);  
334.         spellPut("shuai", -13404);  
335.         spellPut("shuan", -13400);  
336.         spellPut("shuang", -13398);  
337.         spellPut("shui", -13395);  
338.         spellPut("shun", -13391);  
339.         spellPut("shuo", -13387);  
340.         spellPut("si", -13383);  
341.         spellPut("song", -13367);  
342.         spellPut("sou", -13359);  
343.         spellPut("su", -13356);  
344.         spellPut("suan", -13343);  
345.         spellPut("sui", -13340);  
346.         spellPut("sun", -13329);  
347.         spellPut("suo", -13326);  
348.         spellPut("ta", -13318);  
349.         spellPut("tai", -13147);  
350.         spellPut("tan", -13138);  
351.         spellPut("tang", -13120);  
352.         spellPut("tao", -13107);  
353.         spellPut("te", -13096);  
354.         spellPut("teng", -13095);  
355.         spellPut("ti", -13091);  
356.         spellPut("tian", -13076);  
357.         spellPut("tiao", -13068);  
358.         spellPut("tie", -13063);  
359.         spellPut("ting", -13060);  
360.         spellPut("tong", -12888);  
361.         spellPut("tou", -12875);  
362.         spellPut("tu", -12871);  
363.         spellPut("tuan", -12860);  
364.         spellPut("tui", -12858);  
365.         spellPut("tun", -12852);  
366.         spellPut("tuo", -12849);  
367.         spellPut("wa", -12838);  
368.         spellPut("wai", -12831);  
369.         spellPut("wan", -12829);  
370.         spellPut("wang", -12812);  
371.         spellPut("wei", -12802);  
372.         spellPut("wen", -12607);  
373.         spellPut("weng", -12597);  
374.         spellPut("wo", -12594);  
375.         spellPut("wu", -12585);  
376.         spellPut("xi", -12556);  
377.         spellPut("xia", -12359);  
378.         spellPut("xian", -12346);  
379.         spellPut("xiang", -12320);  
380.         spellPut("xiao", -12300);  
381.         spellPut("xie", -12120);  
382.         spellPut("xin", -12099);  
383.         spellPut("xing", -12089);  
384.         spellPut("xiong", -12074);  
385.         spellPut("xiu", -12067);  
386.         spellPut("xu", -12058);  
387.         spellPut("xuan", -12039);  
388.         spellPut("xue", -11867);  
389.         spellPut("xun", -11861);  
390.         spellPut("ya", -11847);  
391.         spellPut("yan", -11831);  
392.         spellPut("yang", -11798);  
393.         spellPut("yao", -11781);  
394.         spellPut("ye", -11604);  
395.         spellPut("yi", -11589);  
396.         spellPut("yin", -11536);  
397.         spellPut("ying", -11358);  
398.         spellPut("yo", -11340);  
399.         spellPut("yong", -11339);  
400.         spellPut("you", -11324);  
401.         spellPut("yu", -11303);  
402.         spellPut("yuan", -11097);  
403.         spellPut("yue", -11077);  
404.         spellPut("yun", -11067);  
405.         spellPut("za", -11055);  
406.         spellPut("zai", -11052);  
407.         spellPut("zan", -11045);  
408.         spellPut("zang", -11041);  
409.         spellPut("zao", -11038);  
410.         spellPut("ze", -11024);  
411.         spellPut("zei", -11020);  
412.         spellPut("zen", -11019);  
413.         spellPut("zeng", -11018);  
414.         spellPut("zha", -11014);  
415.         spellPut("zhai", -10838);  
416.         spellPut("zhan", -10832);  
417.         spellPut("zhang", -10815);  
418.         spellPut("zhao", -10800);  
419.         spellPut("zhe", -10790);  
420.         spellPut("zhen", -10780);  
421.         spellPut("zheng", -10764);  
422.         spellPut("zhi", -10587);  
423.         spellPut("zhong", -10544);  
424.         spellPut("zhou", -10533);  
425.         spellPut("zhu", -10519);  
426.         spellPut("zhua", -10331);  
427.         spellPut("zhuai", -10329);  
428.         spellPut("zhuan", -10328);  
429.         spellPut("zhuang", -10322);  
430.         spellPut("zhui", -10315);  
431.         spellPut("zhun", -10309);  
432.         spellPut("zhuo", -10307);  
433.         spellPut("zi", -10296);  
434.         spellPut("zong", -10281);  
435.         spellPut("zou", -10274);  
436.         spellPut("zu", -10270);  
437.         spellPut("zuan", -10262);  
438.         spellPut("zui", -10260);  
439.         spellPut("zun", -10256);  
440.         spellPut("zuo", -10254);  
441.     }  
442.   
443.     /** 
444.      * 获得单个汉字的Ascii. 
445.      *  
446.      * @param cn 
447.      *            char 汉字字符 
448.      * @return int 错误返回 0,否则返回ascii 
449.      */  
450.     public static int getCnAscii(char cn) {  
451.         byte[] bytes = (String.valueOf(cn)).getBytes();  
452.         if (bytes == null || bytes.length > 2 || bytes.length <= 0) { // 错误  
453.             return 0;  
454.         }  
455.         if (bytes.length == 1) { // 英文字符  
456.             return bytes[0];  
457.         }  
458.         if (bytes.length == 2) { // 中文字符  
459.             int hightByte = 256 + bytes[0];  
460.             int lowByte = 256 + bytes[1];  
461.   
462.             int ascii = (256 * hightByte + lowByte) - 256 * 256;  
463.   
464.             // System.out.println("ASCII=" + ascii);  
465.   
466.             return ascii;  
467.         }  
468.   
469.         return 0; // 错误  
470.     }  
471.   
472.     /** 
473.      * 根据ASCII码到SpellMap中查找对应的拼音 
474.      *  
475.      * @param ascii 
476.      *            int 字符对应的ASCII 
477.      * @return String 拼音,首先判断ASCII是否>0&<160,如果是返回对应的字符, 
478.      *  
479.      * 否则到SpellMap中查找,如果没有找到拼音,则返回null,如果找到则返回拼音. 
480.      */  
481.     public static String getSpellByAscii(int ascii) {  
482.         if (ascii > 0 && ascii < 160) { // 单字符  
483.             return String.valueOf((char) ascii);  
484.         }  
485.   
486.         if (ascii < -20319 || ascii > -10247) { // 不知道的字符  
487.             return null;  
488.         }  
489.   
490.         Set keySet = spellMap.keySet();  
491.         Iterator it = keySet.iterator();  
492.   
493.         String spell0 = null;  
494.         ;  
495.         String spell = null;  
496.   
497.         int asciiRang0 = -20319;  
498.         int asciiRang;  
499.         while (it.hasNext()) {  
500.   
501.             spell = (String) it.next();  
502.             Object valObj = spellMap.get(spell);  
503.             if (valObj instanceof Integer) {  
504.                 asciiRang = ((Integer) valObj).intValue();  
505.   
506.                 if (ascii >= asciiRang0 && ascii < asciiRang) { // 区间找到  
507.                     return (spell0 == null) ? spell : spell0;  
508.                 } else {  
509.                     spell0 = spell;  
510.                     asciiRang0 = asciiRang;  
511.                 }  
512.             }  
513.         }  
514.   
515.         return null;  
516.   
517.     }  
518.   
519.     /** 
520.      * 返回字符串的全拼,是汉字转化为全拼,其它字符不进行转换 
521.      *  
522.      * @param cnStr 
523.      *            String 字符串 
524.      * @return String 转换成全拼后的字符串 
525.      */  
526.     public static String getFullSpell(String cnStr) {  
527.         if (null == cnStr || "".equals(cnStr.trim())) {  
528.             return cnStr;  
529.         }  
530.         char[] chars = cnStr.toCharArray();  
531.         StringBuffer retuBuf = new StringBuffer();  
532.         for (int i = 0, Len = chars.length; i < Len; i++) {  
533.             int ascii = getCnAscii(chars[i]);  
534.             if (ascii == 0) { // 取ascii时出错  
535.                 retuBuf.append(chars[i]);  
536.             } else {  
537.                 String spell = getSpellByAscii(ascii);  
538.                 if (spell == null) {  
539.                     retuBuf.append(chars[i]);  
540.                 } else {  
541.                     retuBuf.append(spell);  
542.                 } // end of if spell == null  
543.             } // end of if ascii <= -20400  
544.         } // end of for  
545.   
546.         return retuBuf.toString();  
547.     }  
548.   
549.     /** 
550.      * 返回字符串的拼音的首字母,是汉字转化为全拼,其它字符不进行转换 
551.      *  
552.      * @param cnStr 
553.      *            String 字符串 
554.      * @return String 转换成全拼后的字符串的首字母 
555.      */  
556.     public static String getFirstSpell(String cnStr) {  
557.         if (cnStr.substring(0, 1).equals("沣"))  
558.             return "f";  
559.         if (cnStr.substring(0, 1).equals("骊"))  
560.             return "l";  
561.         if (cnStr.substring(0, 1).equals("杈"))  
562.             return "c";  
563.         if (cnStr.substring(0, 1).equals("阿"))  
564.             return "e";  
565.         if (cnStr.substring(0, 1).equals("怡"))  
566.             return "y";  
567.         if (cnStr.substring(0, 1).equals("灞"))  
568.             return "b";  
569.         else  
570.             return getFullSpell(cnStr).substring(0, 1);  
571.     }  
572.   
573.     /** 
574.      * 返回字符串的拼音的首字母的关键码值,是汉字转化为全拼,其它字符不进行转换 
575.      *  
576.      * @param cnStr 
577.      *            String 字符串 
578.      * @return String 转换成全拼后的字符串的首字母的关键码值 这儿的关键码设为从0到26的数字 
579.      */  
580.     public static int getKey(String str) {  
581.         return +getFirstSpell(str).charAt(0) - 97;  
582.     }  
583.   
584.     public static void main(String[] args) {  
585.         String s = "张三";  
586.         System.out.println(getFullSpell(s));  
587.     }  
588. }  

 

 

2.

Java代码  

1. package com.zkq.framework.util;  
2.   
3. /** 
4.  * @explain: 
5.  *  
6.  * @author: zkq 
7.  *  
8.  * @createtime: 2009-12-13 上午09:46:54 
9.  *  
10.  * @version: 
11.  *  
12.  */  
13. public class StringUtil {  
14.     // 国标码和区位码转换常量  
15.     static final int GB_SP_DIFF = 160;  
16.     // 存放国标一级汉字不同读音的起始区位码  
17.     static final int[] secPosValueList = { 1601, 1637, 1833, 2078, 2274, 2302,  
18.             2433, 2594, 2787, 3106, 3212, 3472, 3635, 3722, 3730, 3858, 4027,  
19.             4086, 4390, 4558, 4684, 4925, 5249, 5600 };  
20.     // 存放国标一级汉字不同读音的起始区位码对应读音  
21.     static final char[] firstLetter = { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',  
22.             'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'w', 'x',  
23.             'y', 'z' };  
24.   
25.     // 获取一个字符串的拼音码  
26.     public static String getFirstLetter(String oriStr) {  
27.         String str = oriStr.toLowerCase();  
28.         StringBuffer buffer = new StringBuffer();  
29.         char ch;  
30.         char[] temp;  
31.         for (int i = 0; i < str.length(); i++) { // 依次处理str中每个字符  
32.             ch = str.charAt(i);  
33.             temp = new char[] { ch };  
34.             byte[] uniCode = new String(temp).getBytes();  
35.             if (uniCode[0] < 128 && uniCode[0] > 0) { // 非汉字  
36.                 buffer.append(temp);  
37.             } else {  
38.                 buffer.append(convert(uniCode));  
39.             }  
40.         }  
41.         return buffer.toString();  
42.     }  
43.   
44.     /** 
45.      * 获取一个汉字的拼音首字母。 GB码两个字节分别减去160，转换成10进制码组合就可以得到区位码 
46.      * 例如汉字“你”的GB码是0xC4/0xE3，分别减去0xA0（160）就是0x24/0x43 
47.      * 0x24转成10进制就是36，0x43是67，那么它的区位码就是3667，在对照表中读音为‘n’ 
48.      */  
49.     static char convert(byte[] bytes) {  
50.         char result = '-';  
51.         int secPosValue = 0;  
52.         int i;  
53.         for (i = 0; i < bytes.length; i++) {  
54.             bytes[i] -= GB_SP_DIFF;  
55.         }  
56.         secPosValue = bytes[0] * 100 + bytes[1];  
57.         for (i = 0; i < 23; i++) {  
58.             if (secPosValue >= secPosValueList[i]  
59.                     && secPosValue < secPosValueList[i + 1]) {  
60.                 result = firstLetter[i];  
61.                 break;  
62.             }  
63.         }  
64.         return result;  
65.     }  
66.   
67.     public static void main(String[] args) {  
68.         //System.out.println(StringUtil.getFirstLetter("I love u"));  
69.         //System.out.println(StringUtil.getFirstLetter("张三"));  
70.         //System.out.println(StringUtil.getFirstLetter("I love 张三"));  
71.           
72.     }  
73. }  

  

 

3. 个人认为最好的一种方法 是利用 Pinyin4J

首先下载 http://sourceforge.net/projects/pinyin4j/files/pinyin4j-2.5.0/pinyin4j-2.5.0/pinyin4j-2.5.0.zip/download?use_mirror=ncu           Pinyin4J

 

Java代码  

1. package com.zkq.framework.util;     
2.   
3. import net.sourceforge.pinyin4j.PinyinHelper;  
4. import net.sourceforge.pinyin4j.format.HanyuPinyinCaseType;  
5. import net.sourceforge.pinyin4j.format.HanyuPinyinOutputFormat;  
6. import net.sourceforge.pinyin4j.format.HanyuPinyinToneType;  
7. import net.sourceforge.pinyin4j.format.HanyuPinyinVCharType;  
8. import net.sourceforge.pinyin4j.format.exception.BadHanyuPinyinOutputFormatCombination;  
9.     
10. /**   
11.  * @explain:  
12.   
13.  * @author: zkq   
14.     
15.  * @createtime: 2009-12-13 上午10:13:46   
16.   
17.  * @version:   
18.     
19.  */  
20. public class GetPinyin {  
21.       
22.     /** 
23.      * 得到 全拼 
24.      * @param src 
25.      * @return 
26.      */  
27.     public static String getPingYin(String src){   
28.         char[] t1 = null;   
29.         t1=src.toCharArray();   
30.         String[] t2 = new String[t1.length];   
31.         HanyuPinyinOutputFormat t3 = new HanyuPinyinOutputFormat();   
32.         t3.setCaseType(HanyuPinyinCaseType.LOWERCASE);   
33.         t3.setToneType(HanyuPinyinToneType.WITHOUT_TONE);   
34.         t3.setVCharType(HanyuPinyinVCharType.WITH_V);   
35.         String t4="";   
36.         int t0=t1.length;   
37.         try {   
38.           for (int i=0;i<t0;i++) {   
39.           //判断是否为汉字字符   
40.              if(java.lang.Character.toString(t1[i]).matches("[\\u4E00-\\u9FA5]+")) {   
41.                   t2 = PinyinHelper.toHanyuPinyinStringArray(t1[i], t3);                 
42.                   t4+=t2[0];   
43.              } else {  
44.                   t4+=java.lang.Character.toString(t1[i]);   
45.              }  
46.           }   
47.           return t4;   
48.         }   
49.         catch (BadHanyuPinyinOutputFormatCombination e1) {   
50.           e1.printStackTrace();   
51.         }   
52.         return t4;   
53. }   
54.   
55. /** 
56.  * 得到中文首字母 
57.  * @param str 
58.  * @return 
59.  */  
60. public static String getPinYinHeadChar(String str) {   
61.   
62. String convert = "";   
63. for (int j = 0; j < str.length(); j++) {   
64.       char word = str.charAt(j);   
65.       String[] pinyinArray = PinyinHelper.toHanyuPinyinStringArray(word);   
66.       if (pinyinArray != null) {   
67.       convert += pinyinArray[0].charAt(0);   
68.       }else {   
69.       convert += word;   
70.       }   
71. }   
72. return convert;   
73. }   
74. /** 
75.  * 将字符串转移为ASCII码  
76.  * @param cnStr 
77.  * @return 
78.  */  
79. public static String getCnASCII(String cnStr) {   
80.     StringBuffer   strBuf   =   new   StringBuffer();   
81.     byte[]   bGBK   =   cnStr.getBytes();   
82.         for(int   i=0;i <bGBK.length;i++){   
83.             //System.out.println(Integer.toHexString(bGBK[i]&0xff));   
84.             strBuf.append(Integer.toHexString(bGBK[i]&0xff));   
85.         }   
86.         return strBuf.toString();   
87. }   
88. public static void main(String[] args) {   
89.   
90. String cnStr = "戬浜";   
91. System.out.println(getPingYin(cnStr));   
92.                 System.out.println(getPinYinHeadChar(cnStr));   
93. }   
94.   
95. }