`
bobshute
  • 浏览: 284747 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

java汉字转拼音和oracle汉字转拼音

    博客分类:
  • j2se
阅读更多

import   java.util.Iterator;  
  import   java.util.LinkedHashMap;  
  import   java.util.Set;  
   
  /**  
    *  
    汉字转化为全拼  
    *  
    JDK版本:   1.4  
  */  
  public   class   HanziToPingtin   {  
          private   static   LinkedHashMap   spellMap   =   null;  
   
          static   {  
                  if   (spellMap   ==   null)   {  
                          spellMap   =   new   LinkedHashMap(400);  
                  }  
                  initialize();  
                  System.out.println("Chinese   transfer   Spell   Done.");  
          }  
   
          private   static   void   spellPut(String   spell,   int   ascii)   {  
                  spellMap.put(spell,   new   Integer(ascii));  
          }  
   
          private   static   void   initialize()   {  
                  spellPut("a",   -20319);  
                  spellPut("ai",   -20317);  
                  spellPut("an",   -20304);  
                  spellPut("ang",   -20295);  
                  spellPut("ao",   -20292);  
                  spellPut("ba",   -20283);  
                  spellPut("bai",   -20265);  
                  spellPut("ban",   -20257);  
                  spellPut("bang",   -20242);  
                  spellPut("bao",   -20230);  
                  spellPut("bei",   -20051);  
                  spellPut("ben",   -20036);  
                  spellPut("beng",   -20032);  
                  spellPut("bi",   -20026);  
                  spellPut("bian",   -20002);  
                  spellPut("biao",   -19990);  
                  spellPut("bie",   -19986);  
                  spellPut("bin",   -19982);  
                  spellPut("bing",   -19976);  
                  spellPut("bo",   -19805);  
                  spellPut("bu",   -19784);  
                  spellPut("ca",   -19775);  
                  spellPut("cai",   -19774);  
                  spellPut("can",   -19763);  
                  spellPut("cang",   -19756);  
                  spellPut("cao",   -19751);  
                  spellPut("ce",   -19746);  
                  spellPut("ceng",   -19741);  
                  spellPut("cha",   -19739);  
                  spellPut("chai",   -19728);  
                  spellPut("chan",   -19725);  
                  spellPut("chang",   -19715);  
                  spellPut("chao",   -19540);  
                  spellPut("che",   -19531);  
                  spellPut("chen",   -19525);  
                  spellPut("cheng",   -19515);  
                  spellPut("chi",   -19500);  
                  spellPut("chong",   -19484);  
                  spellPut("chou",   -19479);  
                  spellPut("chu",   -19467);  
                  spellPut("chuai",   -19289);  
                  spellPut("chuan",   -19288);  
                  spellPut("chuang",   -19281);  
                  spellPut("chui",   -19275);  
                  spellPut("chun",   -19270);  
                  spellPut("chuo",   -19263);  
                  spellPut("ci",   -19261);  
                  spellPut("cong",   -19249);  
                  spellPut("cou",   -19243);  
                  spellPut("cu",   -19242);  
                  spellPut("cuan",   -19238);  
                  spellPut("cui",   -19235);  
                  spellPut("cun",   -19227);  
                  spellPut("cuo",   -19224);  
                  spellPut("da",   -19218);  
                  spellPut("dai",   -19212);  
                  spellPut("dan",   -19038);  
                  spellPut("dang",   -19023);  
                  spellPut("dao",   -19018);  
                  spellPut("de",   -19006);  
                  spellPut("deng",   -19003);  
                  spellPut("di",   -18996);  
                  spellPut("dian",   -18977);  
                  spellPut("diao",   -18961);  
                  spellPut("die",   -18952);  
                  spellPut("ding",   -18783);  
                  spellPut("diu",   -18774);  
                  spellPut("dong",   -18773);  
                  spellPut("dou",   -18763);  
                  spellPut("du",   -18756);  
                  spellPut("duan",   -18741);  
                  spellPut("dui",   -18735);  
                  spellPut("dun",   -18731);  
                  spellPut("duo",   -18722);  
                  spellPut("e",   -18710);  
                  spellPut("en",   -18697);  
                  spellPut("er",   -18696);  
                  spellPut("fa",   -18526);  
                  spellPut("fan",   -18518);  
                  spellPut("fang",   -18501);  
                  spellPut("fei",   -18490);  
                  spellPut("fen",   -18478);  
                  spellPut("feng",   -18463);  
                  spellPut("fo",   -18448);  
                  spellPut("fou",   -18447);  
                  spellPut("fu",   -18446);  
                  spellPut("ga",   -18239);  
                  spellPut("gai",   -18237);  
                  spellPut("gan",   -18231);  
                  spellPut("gang",   -18220);  
                  spellPut("gao",   -18211);  
                  spellPut("ge",   -18201);  
                  spellPut("gei",   -18184);  
                  spellPut("gen",   -18183);  
                  spellPut("geng",   -18181);  
                  spellPut("gong",   -18012);  
                  spellPut("gou",   -17997);  
                  spellPut("gu",   -17988);  
                  spellPut("gua",   -17970);  
                  spellPut("guai",   -17964);  
                  spellPut("guan",   -17961);  
                  spellPut("guang",   -17950);  
                  spellPut("gui",   -17947);  
                  spellPut("gun",   -17931);  
                  spellPut("guo",   -17928);  
                  spellPut("ha",   -17922);  
                  spellPut("hai",   -17759);  
                  spellPut("han",   -17752);  
                  spellPut("hang",   -17733);  
                  spellPut("hao",   -17730);  
                  spellPut("he",   -17721);  
                  spellPut("hei",   -17703);  
                  spellPut("hen",   -17701);  
                  spellPut("heng",   -17697);  
                  spellPut("hong",   -17692);  
                  spellPut("hou",   -17683);  
                  spellPut("hu",   -17676);  
                  spellPut("hua",   -17496);  
                  spellPut("huai",   -17487);  
                  spellPut("huan",   -17482);  
                  spellPut("huang",   -17468);  
                  spellPut("hui",   -17454);  
                  spellPut("hun",   -17433);  
                  spellPut("huo",   -17427);  
                  spellPut("ji",   -17417);  
                  spellPut("jia",   -17202);  
                  spellPut("jian",   -17185);  
                  spellPut("jiang",   -16983);  
                  spellPut("jiao",   -16970);  
                  spellPut("jie",   -16942);  
                  spellPut("jin",   -16915);  
                  spellPut("jing",   -16733);  
                  spellPut("jiong",   -16708);  
                  spellPut("jiu",   -16706);  
                  spellPut("ju",   -16689);  
                  spellPut("juan",   -16664);  
                  spellPut("jue",   -16657);  
                  spellPut("jun",   -16647);  
                  spellPut("ka",   -16474);  
                  spellPut("kai",   -16470);  
                  spellPut("kan",   -16465);  
                  spellPut("kang",   -16459);  
                  spellPut("kao",   -16452);  
                  spellPut("ke",   -16448);  
 
                  spellPut("ken",   -16433);  
                  spellPut("keng",   -16429);  
                  spellPut("kong",   -16427);  
                  spellPut("kou",   -16423);  
                  spellPut("ku",   -16419);  
                  spellPut("kua",   -16412);  
                  spellPut("kuai",   -16407);  
                  spellPut("kuan",   -16403);  
                  spellPut("kuang",   -16401);  
                  spellPut("kui",   -16393);  
                  spellPut("kun",   -16220);  
                  spellPut("kuo",   -16216);  
                  spellPut("la",   -16212);  
                  spellPut("lai",   -16205);  
                  spellPut("lan",   -16202);  
                  spellPut("lang",   -16187);  
                  spellPut("lao",   -16180);  
                  spellPut("le",   -16171);  
                  spellPut("lei",   -16169);  
                  spellPut("leng",   -16158);  
                  spellPut("li",   -16155);  
                  spellPut("lia",   -15959);  
                  spellPut("lian",   -15958);  
                  spellPut("liang",   -15944);  
                  spellPut("liao",   -15933);  
                  spellPut("lie",   -15920);  
                  spellPut("lin",   -15915);  
                  spellPut("ling",   -15903);  
                  spellPut("liu",   -15889);  
                  spellPut("long",   -15878);  
                  spellPut("lou",   -15707);  
                  spellPut("lu",   -15701);  
                  spellPut("lv",   -15681);  
                  spellPut("luan",   -15667);  
                  spellPut("lue",   -15661);  
                  spellPut("lun",   -15659);  
                  spellPut("luo",   -15652);  
                  spellPut("ma",   -15640);  
                  spellPut("mai",   -15631);  
                  spellPut("man",   -15625);  
                  spellPut("mang",   -15454);  
                  spellPut("mao",   -15448);  
                  spellPut("me",   -15436);  
                  spellPut("mei",   -15435);  
                  spellPut("men",   -15419);  
                  spellPut("meng",   -15416);  
                  spellPut("mi",   -15408);  
                  spellPut("mian",   -15394);  
                  spellPut("miao",   -15385);  
                  spellPut("mie",   -15377);  
                  spellPut("min",   -15375);  
                  spellPut("ming",   -15369);  
                  spellPut("miu",   -15363);  
                  spellPut("mo",   -15362);  
                  spellPut("mou",   -15183);  
                  spellPut("mu",   -15180);  
                  spellPut("na",   -15165);  
                  spellPut("nai",   -15158);  
                  spellPut("nan",   -15153);  
                  spellPut("nang",   -15150);  
                  spellPut("nao",   -15149);  
                  spellPut("ne",   -15144);  
                  spellPut("nei",   -15143);  
                  spellPut("nen",   -15141);  
                  spellPut("neng",   -15140);  
                  spellPut("ni",   -15139);  
                  spellPut("nian",   -15128);  
                  spellPut("niang",   -15121);  
                  spellPut("niao",   -15119);  
                  spellPut("nie",   -15117);  
                  spellPut("nin",   -15110);  
                  spellPut("ning",   -15109);  
                  spellPut("niu",   -14941);  
                  spellPut("nong",   -14937);  
                  spellPut("nu",   -14933);  
                  spellPut("nv",   -14930);  
                  spellPut("nuan",   -14929);  
                  spellPut("nue",   -14928);  
                  spellPut("nuo",   -14926);  
                  spellPut("o",   -14922);  
                  spellPut("ou",   -14921);  
                  spellPut("pa",   -14914);  
                  spellPut("pai",   -14908);  
                  spellPut("pan",   -14902);  
                  spellPut("pang",   -14894);  
                  spellPut("pao",   -14889);  
                  spellPut("pei",   -14882);  
                  spellPut("pen",   -14873);  
                  spellPut("peng",   -14871);  
                  spellPut("pi",   -14857);  
                  spellPut("pian",   -14678);  
                  spellPut("piao",   -14674);  
                  spellPut("pie",   -14670);  
                  spellPut("pin",   -14668);  
                  spellPut("ping",   -14663);  
                  spellPut("po",   -14654);  
                  spellPut("pu",   -14645);  
                  spellPut("qi",   -14630);  
                  spellPut("qia",   -14594);  
                  spellPut("qian",   -14429);  
                  spellPut("qiang",   -14407);  
                  spellPut("qiao",   -14399);  
                  spellPut("qie",   -14384);  
                  spellPut("qin",   -14379);  
                  spellPut("qing",   -14368);  
                  spellPut("qiong",   -14355);  
                  spellPut("qiu",   -14353);  
                  spellPut("qu",   -14345);  
                  spellPut("quan",   -14170);  
                  spellPut("que",   -14159);  
                  spellPut("qun",   -14151);  
                  spellPut("ran",   -14149);  
                  spellPut("rang",   -14145);  
                  spellPut("rao",   -14140);  
                  spellPut("re",   -14137);  
                  spellPut("ren",   -14135);  
                  spellPut("reng",   -14125);  
                  spellPut("ri",   -14123);  
                  spellPut("rong",   -14122);  
                  spellPut("rou",   -14112);  
                  spellPut("ru",   -14109);  
                  spellPut("ruan",   -14099);  
                  spellPut("rui",   -14097);  
                  spellPut("run",   -14094);  
                  spellPut("ruo",   -14092);  
                  spellPut("sa",   -14090);  
                  spellPut("sai",   -14087);  
                  spellPut("san",   -14083);  
                  spellPut("sang",   -13917);  
                  spellPut("sao",   -13914);  
                  spellPut("se",   -13910);  
                  spellPut("sen",   -13907);  
                  spellPut("seng",   -13906);  
                  spellPut("sha",   -13905);  
                  spellPut("shai",   -13896);  
                  spellPut("shan",   -13894);  
                  spellPut("shang",   -13878);  
                  spellPut("shao",   -13870);  
                  spellPut("she",   -13859);  
                  spellPut("shen",   -13847);  
                  spellPut("sheng",   -13831);  
                  spellPut("shi",   -13658);  
                  spellPut("shou",   -13611);  
                  spellPut("shu",   -13601);  
                  spellPut("shua",   -13406);  
                  spellPut("shuai",   -13404);  
                  spellPut("shuan",   -13400);  
                  spellPut("shuang",   -13398);  
                  spellPut("shui",   -13395);  
                  spellPut("shun",   -13391);  
                  spellPut("shuo",   -13387);  
                  spellPut("si",   -13383);  
                  spellPut("song",   -13367);  
                  spellPut("sou",   -13359);  
                  spellPut("su",   -13356);  
                  spellPut("suan",   -13343);  
                  spellPut("sui",   -13340);  
                  spellPut("sun",   -13329);  
                  spellPut("suo",   -13326);  
                  spellPut("ta",   -13318);  
                  spellPut("tai",   -13147);  
                  spellPut("tan",   -13138);  
                  spellPut("tang",   -13120);  
                  spellPut("tao",   -13107);  
                  spellPut("te",   -13096);  
                  spellPut("teng",   -13095);  
                  spellPut("ti",   -13091);  
                  spellPut("tian",   -13076);  
                  spellPut("tiao",   -13068);  
                  spellPut("tie",   -13063);  
                  spellPut("ting",   -13060);  
                  spellPut("tong",   -12888);  
                  spellPut("tou",   -12875);  
                  spellPut("tu",   -12871);  
                  spellPut("tuan",   -12860);  
 
                  spellPut("tui",   -12858);  
                  spellPut("tun",   -12852);  
                  spellPut("tuo",   -12849);  
                  spellPut("wa",   -12838);  
                  spellPut("wai",   -12831);  
                  spellPut("wan",   -12829);  
                  spellPut("wang",   -12812);  
                  spellPut("wei",   -12802);  
                  spellPut("wen",   -12607);  
                  spellPut("weng",   -12597);  
                  spellPut("wo",   -12594);  
                  spellPut("wu",   -12585);  
                  spellPut("xi",   -12556);  
                  spellPut("xia",   -12359);  
                  spellPut("xian",   -12346);  
                  spellPut("xiang",   -12320);  
                  spellPut("xiao",   -12300);  
                  spellPut("xie",   -12120);  
                  spellPut("xin",   -12099);  
                  spellPut("xing",   -12089);  
                  spellPut("xiong",   -12074);  
                  spellPut("xiu",   -12067);  
                  spellPut("xu",   -12058);  
                  spellPut("xuan",   -12039);  
                  spellPut("xue",   -11867);  
                  spellPut("xun",   -11861);  
                  spellPut("ya",   -11847);  
                  spellPut("yan",   -11831);  
                  spellPut("yang",   -11798);  
                  spellPut("yao",   -11781);  
                  spellPut("ye",   -11604);  
                  spellPut("yi",   -11589);  
                  spellPut("yin",   -11536);  
                  spellPut("ying",   -11358);  
                  spellPut("yo",   -11340);  
                  spellPut("yong",   -11339);  
                  spellPut("you",   -11324);  
                  spellPut("yu",   -11303);  
                  spellPut("yuan",   -11097);  
                  spellPut("yue",   -11077);  
                  spellPut("yun",   -11067);  
                  spellPut("za",   -11055);  
                  spellPut("zai",   -11052);  
                  spellPut("zan",   -11045);  
                  spellPut("zang",   -11041);  
                  spellPut("zao",   -11038);  
                  spellPut("ze",   -11024);  
                  spellPut("zei",   -11020);  
                  spellPut("zen",   -11019);  
                  spellPut("zeng",   -11018);  
                  spellPut("zha",   -11014);  
                  spellPut("zhai",   -10838);  
                  spellPut("zhan",   -10832);  
                  spellPut("zhang",   -10815);  
                  spellPut("zhao",   -10800);  
                  spellPut("zhe",   -10790);  
                  spellPut("zhen",   -10780);  
                  spellPut("zheng",   -10764);  
                  spellPut("zhi",   -10587);  
                  spellPut("zhong",   -10544);  
                  spellPut("zhou",   -10533);  
                  spellPut("zhu",   -10519);  
                  spellPut("zhua",   -10331);  
                  spellPut("zhuai",   -10329);  
                  spellPut("zhuan",   -10328);  
                  spellPut("zhuang",   -10322);  
                  spellPut("zhui",   -10315);  
                  spellPut("zhun",   -10309);  
                  spellPut("zhuo",   -10307);  
                  spellPut("zi",   -10296);  
                  spellPut("zong",   -10281);  
                  spellPut("zou",   -10274);  
                  spellPut("zu",   -10270);  
                  spellPut("zuan",   -10262);  
                  spellPut("zui",   -10260);  
                  spellPut("zun",   -10256);  
                  spellPut("zuo",   -10254);  
          }  
   
          /**  
            *   获得单个汉字的Ascii.  
            *   @param   cn   char  
            *   汉字字符  
            *   @return   int  
            *   错误返回   0,否则返回ascii  
            */  
          public   static   int   getCnAscii(char   cn)   {  
                  byte[]   bytes   =   (String.valueOf(cn)).getBytes();  
                  if   (bytes   ==   null   ||   bytes.length   >   2   ||   bytes.length   <=   0)   {   //错误  
                          return   0;  
                  }  
                  if   (bytes.length   ==   1)   {   //英文字符  
                          return   bytes[0];  
                  }  
                  if   (bytes.length   ==   2)   {   //中文字符  
                          int   hightByte   =   256   +   bytes[0];  
                          int   lowByte   =   256   +   bytes[1];  
   
                          int   ascii   =   (256   *   hightByte   +   lowByte)   -   256   *   256;  
   
  //System.out.println("ASCII="   +   ascii);  
   
                          return   ascii;  
                  }  
   
                  return   0;   //错误  
          }  
   
          /**  
            *   根据ASCII码到SpellMap中查找对应的拼音  
            *   @param   ascii   int  
            *   字符对应的ASCII  
            *   @return   String  
            *   拼音,首先判断ASCII是否>0&<160,如果是返回对应的字符,  
            *  
            否则到SpellMap中查找,如果没有找到拼音,则返回null,如果找到则返回拼音.  
            */  
          public   static   String   getSpellByAscii(int   ascii)   {  
                  if   (ascii   >   0   &&   ascii   <   160)   {   //单字符  
                          return   String.valueOf((char)   ascii);  
                  }  
   
                  if   (ascii   <   -20319   ||   ascii   >   -10247)   {   //不知道的字符  
                          return   null;  
                  }  
   
                  Set   keySet   =   spellMap.keySet();  
                  Iterator   it   =   keySet.iterator();  
   
                  String   spell0   =   null;   ;  
                  String   spell   =   null;  
   
                  int   asciiRang0   =   -20319;  
                  int   asciiRang;  
                  while   (it.hasNext())   {  
   
                          spell   =   (String)   it.next();  
                          Object   valObj   =   spellMap.get(spell);  
                          if   (valObj   instanceof   Integer)   {  
                                  asciiRang   =   ((Integer)   valObj).intValue();  
   
                                  if   (ascii   >=   asciiRang0   &&   ascii   <   asciiRang)   {   //区间找到  
                                          return   (spell0   ==   null)   ?   spell   :   spell0;  
                                  }   else   {  
                                          spell0   =   spell;  
                                          asciiRang0   =   asciiRang;  
                                  }  
                          }  
                  }  
   
                  return   null;  
   
          }  
   
          /**  
            *   返回字符串的全拼,是汉字转化为全拼,其它字符不进行转换  
            *   @param   cnStr   String  
            *   字符串  
            *   @return   String  
            *   转换成全拼后的字符串  
            */  
          public   static   String   getFullSpell(String   cnStr)   {  
                  if   (null   ==   cnStr   ||   "".equals(cnStr.trim()))   {  
                          return   cnStr;  
                  }  
   
                  char[]   chars   =   cnStr.toCharArray();  
                  StringBuffer   retuBuf   =   new   StringBuffer();  
                  for   (int   i   =   0,   Len   =   chars.length;   i   <   Len;   i++)   {  
                          int   ascii   =   getCnAscii(chars[i]);  
                          if   (ascii   ==   0)   {   //取ascii时出错  
                                  retuBuf.append(chars[i]);  
                          }   else   {  
                                  String   spell   =   getSpellByAscii(ascii);  
                                  if   (spell   ==   null)   {  
                                          retuBuf.append(chars[i]);  
                                  }   else   {  
                                          retuBuf.append(spell);  
                                  }   //   end   of   if   spell   ==   null  
                          }   //   end   of   if   ascii   <=   -20400  
                  }   //   end   of   for  
   
                  return   retuBuf.toString();  
          }  
   
          public   static   String   getFirstSpell(String   cnStr)   {  
                  return   null;  
          }  
   
          public   static   void   main(String[]   args)   {  
                  String   str   =   null;  
                  str   =   "高兴";  
                  System.out.println("Spell="   +   HanziToPingtin.getFullSpell(str));     }  
  }  
   

 

分享到:
评论
1 楼 sunwendong 2010-08-02  
多音字问题。。。。。。

相关推荐

    java汉字转拼音(全拼和首字母)

    在Java编程语言中,汉字转拼音是一项常见的需求,特别是在处理中文数据、搜索引擎优化或文本处理等领域。本篇文章将深入探讨如何使用Java实现汉字转拼音的功能,包括获取汉字的全拼和首字母。 首先,我们需要理解...

    Oracle将汉字转换为拼音的方法

    另外,Oracle的`DBMSaccent`包提供了一个`HANPIN`过程,它可以返回一个汉字的声母、韵母和声调,但这并不直接返回完整的拼音,因此在实际应用中可能不如`UTL_I18N`包方便。 总结来说,Oracle通过`UTL_I18N`包中的`...

    汉字转全拼或首字母Oracle存储过程

    而将汉字转换为拼音,就需要借助特定的算法和字典库,比如Pinyin4j在Java中的应用,或者在Oracle中使用预定义的函数和存储过程。 在Oracle中,由于没有内置的汉字转拼音功能,我们需要自己编写存储过程。"pkg_...

    oracle汉字转拼音的函数代码

    综上所述,"oracle汉字转拼音的函数代码"涉及到的是在Oracle数据库中通过自定义函数实现汉字到拼音的转换,这需要对Oracle的PL/SQL编程、字符编码和语言处理有一定的了解。通过学习并运用这些代码,我们可以增强...

    oracle获取汉字拼音和拼音首字母的功能函数

    总的来说,Oracle中获取汉字拼音和拼音首字母涉及了字符编码、Java编程、自定义函数、第三方工具等多个方面。开发者可以根据具体的需求和环境,选择合适的方法来实现这一功能。在处理过程中,要注意字符集的兼容性、...

    oracle汉字转拼音的各种方法

    可以在Oracle中创建外部函数,利用Java或Python等编程语言的汉字转拼音库(如Java的Pinyin4j,Python的pypinyin)进行转换。这种方法灵活性高,但涉及到数据库与外部环境的交互,可能需要关注安全性和性能。 5. **...

    oracle package汉字转拼音 简拼

    使用上述`oracle汉字转拼音package_获得全拼——拼音首字母_拼音截取等.sql`文件,可能包含的就是创建这样一个存储过程或包的SQL脚本。脚本中可能定义了以下过程: ```sql CREATE OR REPLACE AND COMPILE JAVA ...

    Oracle获取汉字拼音和拼音首字母的功能函数

    本文将详细讲解如何在Oracle中实现获取汉字的拼音和拼音首字母的功能。 首先,我们要知道Oracle并不内置直接支持汉字转拼音的函数。但是,我们可以利用一些额外的资源,比如创建存储过程或者使用第三方的PL/SQL包来...

    oracle获取汉字拼音首字母

    在Oracle数据库中实现获取汉字拼音首字母的需求,通常涉及到对中文字符的处理以及拼音转换的技术。这样的功能可以应用于多种场景,例如数据排序、索引建立或是快速检索等。本文将详细介绍如何在Oracle环境中实现这一...

    js汉字转拼音及汉字转拼音首字母

    首先,汉字转拼音是将中文字符转换为对应的汉语拼音,这对于搜索引擎优化(SEO)尤其有用,因为它允许非中文用户通过输入拼音来搜索中文内容。另一方面,汉字转拼音首字母则是获取每个汉字的首字母,这种技术常用于...

    oracle拼音首字母查询

    在Oracle中,拼音首字母查询通常依赖于两个关键步骤:汉字到拼音的转换和基于拼音首字母的查询。汉字到拼音的转换可以使用第三方工具或者自定义函数来实现,例如使用Java或C++编写一个外部过程,将汉字转换为相应的...

    中文转换为拼音java

    Pinyin4j是一个Java库,用于处理中文字符和拼音之间的转换。它能够处理多音字,并提供声调标记的选项。使用Pinyin4j,你可以如下所示将中文字符串转换为拼音: ```java import ...

    把汉字转为拼音

    因为Oracle的内置函数对汉字拼音的支持有限,而Java有丰富的库(如Pinyin4j)可以方便地处理汉字转拼音。通过编写一个Java类,使用Pinyin4j库,然后在Oracle中调用这个Java过程,可以有效地解决这个问题。 具体步骤...

    Oracle函数取得姓名对应的拼音 字典数据

    一个常见的解决方案是使用Oracle的JDBC驱动和Java的`com.sun.org.apache.xerces.internal.jaxp.TransformerFactoryImpl`类,它提供了对XML文档处理的功能,同时也包含了汉字转拼音的能力。在Oracle的PL/SQL环境中,...

    oracle 获取拼音码函数

    在Oracle数据库中,获取汉字的拼音码是一项常见的需求,特别是在处理中文数据时,例如进行全文检索、数据分析...了解如何在Oracle中实现汉字转拼音,对于处理中文数据的数据库管理员和开发人员来说是非常有用的技能。

    Android-JavaAndroid中文转拼音稳如狗

    总之,`Android-JavaAndroid中文转拼音稳如狗`项目为Android开发者提供了一种可靠的中文转拼音解决方案,利用Java和第三方库`pinyin4j`,确保了在处理中文字符时的稳定性和效率。通过深入理解和运用这些技术,我们...

    ORACLE中文转简拼存储方法

    总之,"ORACLE中文转简拼存储方法"是一个实用的工具,它利用Oracle的PL/SQL和可能的Java扩展,实现了高效的中文到简拼的转换,广泛适用于各种需要处理中文数据的场合。正确理解和使用这个方法,将有助于提升你在...

    关于Oracle中转中文,获取首字母的问题

    在Oracle数据库中处理中文字符,特别是需要将汉字转换为拼音并获取首字母,是一个常见的需求。这在构建索引、搜索优化或者特定的数据处理场景中非常有用。本篇将详细探讨如何在Oracle环境下实现这个功能。 首先,...

    ORACLE-pinyin.rar_oracle_拼音

    在Oracle数据库系统中,处理汉字拼音的需求时常出现,特别是在进行数据检索、中文排序或与中文字符串相关的业务逻辑中。"ORACLE-pinyin.rar_oracle_拼音"这个压缩包文件很可能包含了一个或多个实用的PL/SQL函数,...

    取汉字拼音或首字母的PL/SQL存储过程

    总的来说,通过PL/SQL的存储过程,我们可以有效地在Oracle数据库中处理汉字转拼音的需求,这在中文信息处理、索引或搜索等场景中非常有用。不过,需要注意的是,由于Oracle的内置函数限制,这种方法可能无法处理所有...

Global site tag (gtag.js) - Google Analytics