精华内容
下载资源
问答
  • 下载汉字转拼音手机应用
    2018-01-17 16:29:00
    包地址
     
    1. 简单介绍
    有时候,需要将汉字编程对应的拼音,以方便数据的处理。比如在Android手机应用的开发上,要查询联系人的姓名,通常都是用拼音进行查询的。比如要查询曹孟德,就可以输入cmd,即曹孟德三个汉字的拼音caomengde各字的首字母。但是怎样才能将曹孟德翻译成caomengde呢?很简单的办法就是建立一个大的对照表(比如用关联容器Map),比如<cao><” meng><” de>但这样的做法,需要维护好一个比较大的对照表,同时一个汉字可能有多个发音,也就是说Map这样的容器时不行的,因为其<key,value>必须是一一对应的。在C++中可以用STL里面的multimap来解决这个问题,但Java中没有类似multimap这样的东西,除非自己实现一个。
     
    Pinyin4j就是为了解决类似这样的问题的。它是sourceforge.net上的一个开源项目,功能非常强大:
    支持同一汉字有多个发音
    还支持拼音的格式化输出,比如第几声之类的,
    同时支持简体中文、繁体中文转换为拼音使用起来也非常简单。下面是其官方网址,其中提供了下载:
     
    2. 基本用法:
    通常情况下,只需要用到其中的PinyinHelper类中的静态方法toHanyuPinyinStringArray就可以了,比如:
    String[] pinyinArray =PinyinHelper.toHanyuPinyinStringArray('');
    for(int i = 0; i < pinyinArray.length; ++i)
    {
    System.out.println(pinyinArray[i]);
    }
    就会输出:
    dan1
    chan2
    shan4
    这三种发音,后面的数字代表第几声。可以看到静态方法toHanyuPinyinStringArray返回的数据类型是一个String数组,它用来接收一个汉字的多个发音,如果toHanyuPinyinStringArray中的参数不是汉字,那么它会返回null
     
    3.格式支持
    Pinyin4j支持拼音输出的格式化,比如,可以输出为huanghuang2huáng等等,下面的代码就似是输出huáng的示例:
    HanyuPinyinOutputFormat format= new HanyuPinyinOutputFormat();
    format.setToneType(HanyuPinyinToneType.WITH_TONE_MARK);
    format.setVCharType(HanyuPinyinVCharType.WITH_U_UNICODE);
     
    String[] pinyinArray = null;
    try
    {
    pinyinArray = PinyinHelper.toHanyuPinyinStringArray('', format);
    }
    catch(BadHanyuPinyinOutputFormatCombination e)
    {
    e.printStackTrace();
    }
    for(int i = 0; i < pinyinArray.length; ++i)
    {
    System.out.println(pinyinArray[i]);
    }
    此外,还支持大小写转换、ü等等。详细情况,可以查看Pinyin4j自带的文档。
     
    4.实际示例代码
    如果我们要将一段文字中的汉字全部转换成不带音调的拼音输出,而这段文字中又可能包含阿拉伯数字、英文、标点符号等等。如果完全靠自己写代码进行转换,那是非常麻烦的,其中一个首先就要区别,这段文字中那些是汉字,那些是非汉字。有了Pinyin4j,这个问题就不再困难了,因为对于非汉字,Pinyin4j会自动输出null。参考下面的示例代码:
    importnet.sourceforge.pinyin4j.*;
    importnet.sourceforge.pinyin4j.format.HanyuPinyinOutputFormat;
    importnet.sourceforge.pinyin4j.format.HanyuPinyinToneType;
    importnet.sourceforge.pinyin4j.format.exception.BadHanyuPinyinOutputFormatCombination;
     
    public class Chinese2PY
    {
    public static void main(String[] args)
    {
    Hanyu hanyu = new Hanyu();
    // 中英文混合的一段文字
    String str = "荆溪白石出,Hello 天寒红叶稀。Android 山路元无雨,What's up? 空翠湿人衣。";
    String strPinyin = hanyu.getStringPinYin(str);
    System.out.println(strPinyin);
    }
    }
     
    class Hanyu
    {
    private HanyuPinyinOutputFormat format = null;
    private String[] pinyin;
     
    public Hanyu()
    {
    format = new HanyuPinyinOutputFormat();
    format.setToneType(HanyuPinyinToneType.WITHOUT_TONE);
     
    pinyin = null;
    }
     
    //转换单个字符
    public String getCharacterPinYin(char c)
    {
    try
    {
    pinyin = PinyinHelper.toHanyuPinyinStringArray(c, format);
    }
    catch(BadHanyuPinyinOutputFormatCombination e)
    {
    e.printStackTrace();
    }
     
    // 如果c不是汉字,toHanyuPinyinStringArray会返回null
    if(pinyin == null) return null;
     
    // 只取一个发音,如果是多音字,仅取第一个发音
    return pinyin[0];
    }
     
    //转换一个字符串
    public String getStringPinYin(String str)
    {
    StringBuilder sb = new StringBuilder();
    String tempPinyin = null;
    for(int i = 0; i < str.length(); ++i)
    {
    tempPinyin =getCharacterPinYin(str.charAt(i));
    if(tempPinyin == null)
    {
    // 如果str.charAt(i)非汉字,则保持原样
    sb.append(str.charAt(i));
    }
    else
    {
    sb.append(tempPinyin);
    }
    }
    return sb.toString();
    }
    }

    转载于:https://www.cnblogs.com/super-admin/p/8303633.html

    更多相关内容
  • 安卓手机-汉字转拼音

    2019-01-01 09:19:47
    用Hbuilder打包做的一个汉字转拼音app 应用大小2.68M 不要求系统敏感权限
  • 汉字转无调华拼软件是一款可以让你轻松把汉字转化为华语拼音的软件,利用这种华语拼音文字,不需要懂任何中文输入法,不需要输入中文字就可以在网络上留言、聊天、发送电邮,也可以在手机上发送短信,而且该软件能...
  • 中文转拼音

    2015-01-14 10:51:38
    比如在Android手机应用的开发上,要查询联系人的姓名,通常都是用拼音进行查询的。比如要查询“曹孟德”,就可以输入“cmd”,即“曹孟德”三个汉字拼音“caomengde”各字的首字母。但是怎样才能将“曹孟德”翻译...
  • Android 汉语转拼音

    2016-08-22 11:43:30
    有很多时候我们需要将汉字转换为拼音,例如手机中的联系人排序、在12306买车票时输入SZ\shenzhen就会提示深圳。 Android提供了汉字转拼音的类HanziToPinyin.java,据说这个类是在联系人app下的。具体目录是packages...

    Android系统本身自带有有将汉字转化为英文拼音的类和方法。具体的类就是HanziToPinyin.Java。Android系统自身实现的通讯录中就使用了HanziToPinyin.java对中文通讯录做分组整理。通过HanziToPinyin.java可以将汉字转化为拼音输出,在一些应用中非常必须,比如联系人的分组,假设一个人通讯录中存有若干姓张(ZHANG)的联系人,那么所有姓张的联系人按理都应该分组在“Z”组下。又比如微信、QQ等等此类社交类APP,凡是涉及到联系人、好友分组排序的应用场景,则均需要将汉字转化为拼音然后依据首字母排序归类。
    HanziToPinyin.java不是一个公开的类,只是谷歌官方内部在实现Android通讯录中私有使用的一个类,我们不能够直接像使用普通Android SDK API一样使用,但这没关系,我们完全可以将这个类文件拷贝出来,放到我们自己的项目中,直接使用。
    HanziToPinyin.java的代码文件,谷歌官方的通讯录APP下:

    packages/providers/ContactsProvider /src/com/android/providers/contacts/HanziToPinyin.java

    网上也有这个HanziToPinyin.java类文件的项目地址。但是,直接使用这个 类不能正常工作,错误原因是:

    "There is no Chinese collator, HanziToPinyin is disabled"

    发生这一错误的代码块是在HanziToPinyin.java的方法:
    public static HanziToPinyin getInstance();
    具体原因是这个方法在一些非原生定制的Android系统中,对中文Locale的定义规则不同,导致原代码文件中的locale[i].equals(Locale.CHINA)返回false,不能识别,致使以后的代码全部失去功效。

    对此问题的修复(解决方案)

    我改进了判断条件,增加一些代码:
    final Locale chinaAddition = new Locale("zh");
    将此chinaAddition作为辅助条件也加入到条件判断中,

    if ( locale[i].equals(Locale.CHINA) ||  locale[i].equals(chinaAddition) ){  
    …  
    } 

    下面是我改进后的getInstance()方法全部代码:
    public static HanziToPinyin getInstance() {  
            synchronized (HanziToPinyin.class) {  
                if (sInstance != null) {  
                    return sInstance;  
                }  
                // Check if zh_CN collation data is available  
                final Locale locale[] = Collator.getAvailableLocales();  
      
                // 增加的代码,增强。  
                final Locale chinaAddition = new Locale("zh");  
      
                for (int i = 0; i < locale.length; i++) {  
                    if (locale[i].equals(Locale.CHINA)  
                            || locale[i].equals(chinaAddition)) {  
                        // Do self validation just once.  
                        if (DEBUG) {  
                            Log.d(TAG, "Self validation. Result: "  
                                    + doSelfValidation());  
                        }  
                        sInstance = new HanziToPinyin(true);  
                        return sInstance;  
                    }  
                }  
                Log.w(TAG,  
                        "There is no Chinese collator, HanziToPinyin is disabled");  
                sInstance = new HanziToPinyin(false);  
                return sInstance;  
            }  
        }  
    经由改进增强,HanziToPinyin.java的全部源代码如下(代码可以复制到自己的项目中直接使用):
    /* 
     * Copyright (C) 2011 The Android Open Source Project 
     * 
     * Licensed under the Apache License, Version 2.0 (the "License"); 
     * you may not use this file except in compliance with the License. 
     * You may obtain a copy of the License at 
     * 
     *      http://www.apache.org/licenses/LICENSE-2.0 
     * 
     * Unless required by applicable law or agreed to in writing, software 
     * distributed under the License is distributed on an "AS IS" BASIS, 
     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
     * See the License for the specific language governing permissions and 
     * limitations under the License. 
     */  
      
    package zhangphil.hanyupinyin;  
      
    import android.text.TextUtils;  
    import android.util.Log;  
      
    import java.text.Collator;  
    import java.util.ArrayList;  
    import java.util.Locale;  
      
    /** 
     * An object to convert Chinese character to its corresponding pinyin string. 
     * For characters with multiple possible pinyin string, only one is selected 
     * according to collator. Polyphone is not supported in this implementation. 
     * This class is implemented to achieve the best runtime performance and minimum 
     * runtime resources with tolerable sacrifice of accuracy. This implementation 
     * highly depends on zh_CN ICU collation data and must be always synchronized 
     * with ICU. 
     * 
     * Currently this file is aligned to zh.txt in ICU 4.6 鏉ヨ嚜android4.2婧愮爜 
     */  
    public class HanziToPinyin {  
        private static final String TAG = "HanziToPinyin";  
      
        // Turn on this flag when we want to check internal data structure.  
        private static final boolean DEBUG = false;  
      
        /** 
         * Unihans array. 
         * 
         * Each unihans is the first one within same pinyin when collator is zh_CN. 
         */  
        public static final char[] UNIHANS = { '\u963f', '\u54ce', '\u5b89',  
                '\u80ae', '\u51f9', '\u516b', '\u6300', '\u6273', '\u90a6',  
                '\u52f9', '\u9642', '\u5954', '\u4f3b', '\u5c44', '\u8fb9',  
                '\u706c', '\u618b', '\u6c43', '\u51ab', '\u7676', '\u5cec',  
                '\u5693', '\u5072', '\u53c2', '\u4ed3', '\u64a1', '\u518a',  
                '\u5d7e', '\u66fd', '\u66fe', '\u5c64', '\u53c9', '\u8286',  
                '\u8fbf', '\u4f25', '\u6284', '\u8f66', '\u62bb', '\u6c88',  
                '\u6c89', '\u9637', '\u5403', '\u5145', '\u62bd', '\u51fa',  
                '\u6b3b', '\u63e3', '\u5ddb', '\u5205', '\u5439', '\u65fe',  
                '\u9034', '\u5472', '\u5306', '\u51d1', '\u7c97', '\u6c46',  
                '\u5d14', '\u90a8', '\u6413', '\u5491', '\u5446', '\u4e39',  
                '\u5f53', '\u5200', '\u561a', '\u6265', '\u706f', '\u6c10',  
                '\u55f2', '\u7538', '\u5201', '\u7239', '\u4e01', '\u4e1f',  
                '\u4e1c', '\u543a', '\u53be', '\u8011', '\u8968', '\u5428',  
                '\u591a', '\u59b8', '\u8bf6', '\u5940', '\u97a5', '\u513f',  
                '\u53d1', '\u5e06', '\u531a', '\u98de', '\u5206', '\u4e30',  
                '\u8985', '\u4ecf', '\u7d11', '\u4f15', '\u65ee', '\u4f85',  
                '\u7518', '\u5188', '\u768b', '\u6208', '\u7ed9', '\u6839',  
                '\u522f', '\u5de5', '\u52fe', '\u4f30', '\u74dc', '\u4e56',  
                '\u5173', '\u5149', '\u5f52', '\u4e28', '\u5459', '\u54c8',  
                '\u548d', '\u4f44', '\u592f', '\u8320', '\u8bc3', '\u9ed2',  
                '\u62eb', '\u4ea8', '\u5677', '\u53ff', '\u9f41', '\u4e6f',  
                '\u82b1', '\u6000', '\u72bf', '\u5ddf', '\u7070', '\u660f',  
                '\u5419', '\u4e0c', '\u52a0', '\u620b', '\u6c5f', '\u827d',  
                '\u9636', '\u5dfe', '\u5755', '\u5182', '\u4e29', '\u51e5',  
                '\u59e2', '\u5658', '\u519b', '\u5494', '\u5f00', '\u520a',  
                '\u5ffc', '\u5c3b', '\u533c', '\u808e', '\u52a5', '\u7a7a',  
                '\u62a0', '\u625d', '\u5938', '\u84af', '\u5bbd', '\u5321',  
                '\u4e8f', '\u5764', '\u6269', '\u5783', '\u6765', '\u5170',  
                '\u5577', '\u635e', '\u808b', '\u52d2', '\u5d1a', '\u5215',  
                '\u4fe9', '\u5941', '\u826f', '\u64a9', '\u5217', '\u62ce',  
                '\u5222', '\u6e9c', '\u56d6', '\u9f99', '\u779c', '\u565c',  
                '\u5a08', '\u7567', '\u62a1', '\u7f57', '\u5463', '\u5988',  
                '\u57cb', '\u5ada', '\u7264', '\u732b', '\u4e48', '\u5445',  
                '\u95e8', '\u753f', '\u54aa', '\u5b80', '\u55b5', '\u4e5c',  
                '\u6c11', '\u540d', '\u8c2c', '\u6478', '\u54de', '\u6bea',  
                '\u55ef', '\u62cf', '\u8149', '\u56e1', '\u56d4', '\u5b6c',  
                '\u7592', '\u5a1e', '\u6041', '\u80fd', '\u59ae', '\u62c8',  
                '\u5b22', '\u9e1f', '\u634f', '\u56dc', '\u5b81', '\u599e',  
                '\u519c', '\u7fba', '\u5974', '\u597b', '\u759f', '\u9ec1',  
                '\u90cd', '\u5594', '\u8bb4', '\u5991', '\u62cd', '\u7705',  
                '\u4e53', '\u629b', '\u5478', '\u55b7', '\u5309', '\u4e15',  
                '\u56e8', '\u527d', '\u6c15', '\u59d8', '\u4e52', '\u948b',  
                '\u5256', '\u4ec6', '\u4e03', '\u6390', '\u5343', '\u545b',  
                '\u6084', '\u767f', '\u4eb2', '\u72c5', '\u828e', '\u4e18',  
                '\u533a', '\u5cd1', '\u7f3a', '\u590b', '\u5465', '\u7a63',  
                '\u5a06', '\u60f9', '\u4eba', '\u6254', '\u65e5', '\u8338',  
                '\u53b9', '\u909a', '\u633c', '\u5827', '\u5a51', '\u77a4',  
                '\u637c', '\u4ee8', '\u6be2', '\u4e09', '\u6852', '\u63bb',  
                '\u95aa', '\u68ee', '\u50e7', '\u6740', '\u7b5b', '\u5c71',  
                '\u4f24', '\u5f30', '\u5962', '\u7533', '\u8398', '\u6552',  
                '\u5347', '\u5c38', '\u53ce', '\u4e66', '\u5237', '\u8870',  
                '\u95e9', '\u53cc', '\u8c01', '\u542e', '\u8bf4', '\u53b6',  
                '\u5fea', '\u635c', '\u82cf', '\u72fb', '\u590a', '\u5b59',  
                '\u5506', '\u4ed6', '\u56fc', '\u574d', '\u6c64', '\u5932',  
                '\u5fd1', '\u71a5', '\u5254', '\u5929', '\u65eb', '\u5e16',  
                '\u5385', '\u56f2', '\u5077', '\u51f8', '\u6e4d', '\u63a8',  
                '\u541e', '\u4e47', '\u7a75', '\u6b6a', '\u5f2f', '\u5c23',  
                '\u5371', '\u6637', '\u7fc1', '\u631d', '\u4e4c', '\u5915',  
                '\u8672', '\u4eda', '\u4e61', '\u7071', '\u4e9b', '\u5fc3',  
                '\u661f', '\u51f6', '\u4f11', '\u5401', '\u5405', '\u524a',  
                '\u5743', '\u4e2b', '\u6079', '\u592e', '\u5e7a', '\u503b',  
                '\u4e00', '\u56d9', '\u5e94', '\u54df', '\u4f63', '\u4f18',  
                '\u625c', '\u56e6', '\u66f0', '\u6655', '\u7b60', '\u7b7c',  
                '\u5e00', '\u707d', '\u5142', '\u5328', '\u50ae', '\u5219',  
                '\u8d3c', '\u600e', '\u5897', '\u624e', '\u635a', '\u6cbe',  
                '\u5f20', '\u957f', '\u9577', '\u4f4b', '\u8707', '\u8d1e',  
                '\u4e89', '\u4e4b', '\u5cd9', '\u5ea2', '\u4e2d', '\u5dde',  
                '\u6731', '\u6293', '\u62fd', '\u4e13', '\u5986', '\u96b9',  
                '\u5b92', '\u5353', '\u4e72', '\u5b97', '\u90b9', '\u79df',  
                '\u94bb', '\u539c', '\u5c0a', '\u6628', '\u5159', '\u9fc3',  
                '\u9fc4', };  
      
        /** 
         * Pinyin array. 
         * 
         * Each pinyin is corresponding to unihans of same offset in the unihans 
         * array. 
         */  
        public static final byte[][] PINYINS = { { 65, 0, 0, 0, 0, 0 },  
                { 65, 73, 0, 0, 0, 0 }, { 65, 78, 0, 0, 0, 0 },  
                { 65, 78, 71, 0, 0, 0 }, { 65, 79, 0, 0, 0, 0 },  
                { 66, 65, 0, 0, 0, 0 }, { 66, 65, 73, 0, 0, 0 },  
                { 66, 65, 78, 0, 0, 0 }, { 66, 65, 78, 71, 0, 0 },  
                { 66, 65, 79, 0, 0, 0 }, { 66, 69, 73, 0, 0, 0 },  
                { 66, 69, 78, 0, 0, 0 }, { 66, 69, 78, 71, 0, 0 },  
                { 66, 73, 0, 0, 0, 0 }, { 66, 73, 65, 78, 0, 0 },  
                { 66, 73, 65, 79, 0, 0 }, { 66, 73, 69, 0, 0, 0 },  
                { 66, 73, 78, 0, 0, 0 }, { 66, 73, 78, 71, 0, 0 },  
                { 66, 79, 0, 0, 0, 0 }, { 66, 85, 0, 0, 0, 0 },  
                { 67, 65, 0, 0, 0, 0 }, { 67, 65, 73, 0, 0, 0 },  
                { 67, 65, 78, 0, 0, 0 }, { 67, 65, 78, 71, 0, 0 },  
                { 67, 65, 79, 0, 0, 0 }, { 67, 69, 0, 0, 0, 0 },  
                { 67, 69, 78, 0, 0, 0 }, { 67, 69, 78, 71, 0, 0 },  
                { 90, 69, 78, 71, 0, 0 }, { 67, 69, 78, 71, 0, 0 },  
                { 67, 72, 65, 0, 0, 0 }, { 67, 72, 65, 73, 0, 0 },  
                { 67, 72, 65, 78, 0, 0 }, { 67, 72, 65, 78, 71, 0 },  
                { 67, 72, 65, 79, 0, 0 }, { 67, 72, 69, 0, 0, 0 },  
                { 67, 72, 69, 78, 0, 0 }, { 83, 72, 69, 78, 0, 0 },  
                { 67, 72, 69, 78, 0, 0 }, { 67, 72, 69, 78, 71, 0 },  
                { 67, 72, 73, 0, 0, 0 }, { 67, 72, 79, 78, 71, 0 },  
                { 67, 72, 79, 85, 0, 0 }, { 67, 72, 85, 0, 0, 0 },  
                { 67, 72, 85, 65, 0, 0 }, { 67, 72, 85, 65, 73, 0 },  
                { 67, 72, 85, 65, 78, 0 }, { 67, 72, 85, 65, 78, 71 },  
                { 67, 72, 85, 73, 0, 0 }, { 67, 72, 85, 78, 0, 0 },  
                { 67, 72, 85, 79, 0, 0 }, { 67, 73, 0, 0, 0, 0 },  
                { 67, 79, 78, 71, 0, 0 }, { 67, 79, 85, 0, 0, 0 },  
                { 67, 85, 0, 0, 0, 0 }, { 67, 85, 65, 78, 0, 0 },  
                { 67, 85, 73, 0, 0, 0 }, { 67, 85, 78, 0, 0, 0 },  
                { 67, 85, 79, 0, 0, 0 }, { 68, 65, 0, 0, 0, 0 },  
                { 68, 65, 73, 0, 0, 0 }, { 68, 65, 78, 0, 0, 0 },  
                { 68, 65, 78, 71, 0, 0 }, { 68, 65, 79, 0, 0, 0 },  
                { 68, 69, 0, 0, 0, 0 }, { 68, 69, 78, 0, 0, 0 },  
                { 68, 69, 78, 71, 0, 0 }, { 68, 73, 0, 0, 0, 0 },  
                { 68, 73, 65, 0, 0, 0 }, { 68, 73, 65, 78, 0, 0 },  
                { 68, 73, 65, 79, 0, 0 }, { 68, 73, 69, 0, 0, 0 },  
                { 68, 73, 78, 71, 0, 0 }, { 68, 73, 85, 0, 0, 0 },  
                { 68, 79, 78, 71, 0, 0 }, { 68, 79, 85, 0, 0, 0 },  
                { 68, 85, 0, 0, 0, 0 }, { 68, 85, 65, 78, 0, 0 },  
                { 68, 85, 73, 0, 0, 0 }, { 68, 85, 78, 0, 0, 0 },  
                { 68, 85, 79, 0, 0, 0 }, { 69, 0, 0, 0, 0, 0 },  
                { 69, 73, 0, 0, 0, 0 }, { 69, 78, 0, 0, 0, 0 },  
                { 69, 78, 71, 0, 0, 0 }, { 69, 82, 0, 0, 0, 0 },  
                { 70, 65, 0, 0, 0, 0 }, { 70, 65, 78, 0, 0, 0 },  
                { 70, 65, 78, 71, 0, 0 }, { 70, 69, 73, 0, 0, 0 },  
                { 70, 69, 78, 0, 0, 0 }, { 70, 69, 78, 71, 0, 0 },  
                { 70, 73, 65, 79, 0, 0 }, { 70, 79, 0, 0, 0, 0 },  
                { 70, 79, 85, 0, 0, 0 }, { 70, 85, 0, 0, 0, 0 },  
                { 71, 65, 0, 0, 0, 0 }, { 71, 65, 73, 0, 0, 0 },  
                { 71, 65, 78, 0, 0, 0 }, { 71, 65, 78, 71, 0, 0 },  
                { 71, 65, 79, 0, 0, 0 }, { 71, 69, 0, 0, 0, 0 },  
                { 71, 69, 73, 0, 0, 0 }, { 71, 69, 78, 0, 0, 0 },  
                { 71, 69, 78, 71, 0, 0 }, { 71, 79, 78, 71, 0, 0 },  
                { 71, 79, 85, 0, 0, 0 }, { 71, 85, 0, 0, 0, 0 },  
                { 71, 85, 65, 0, 0, 0 }, { 71, 85, 65, 73, 0, 0 },  
                { 71, 85, 65, 78, 0, 0 }, { 71, 85, 65, 78, 71, 0 },  
                { 71, 85, 73, 0, 0, 0 }, { 71, 85, 78, 0, 0, 0 },  
                { 71, 85, 79, 0, 0, 0 }, { 72, 65, 0, 0, 0, 0 },  
                { 72, 65, 73, 0, 0, 0 }, { 72, 65, 78, 0, 0, 0 },  
                { 72, 65, 78, 71, 0, 0 }, { 72, 65, 79, 0, 0, 0 },  
                { 72, 69, 0, 0, 0, 0 }, { 72, 69, 73, 0, 0, 0 },  
                { 72, 69, 78, 0, 0, 0 }, { 72, 69, 78, 71, 0, 0 },  
                { 72, 77, 0, 0, 0, 0 }, { 72, 79, 78, 71, 0, 0 },  
                { 72, 79, 85, 0, 0, 0 }, { 72, 85, 0, 0, 0, 0 },  
                { 72, 85, 65, 0, 0, 0 }, { 72, 85, 65, 73, 0, 0 },  
                { 72, 85, 65, 78, 0, 0 }, { 72, 85, 65, 78, 71, 0 },  
                { 72, 85, 73, 0, 0, 0 }, { 72, 85, 78, 0, 0, 0 },  
                { 72, 85, 79, 0, 0, 0 }, { 74, 73, 0, 0, 0, 0 },  
                { 74, 73, 65, 0, 0, 0 }, { 74, 73, 65, 78, 0, 0 },  
                { 74, 73, 65, 78, 71, 0 }, { 74, 73, 65, 79, 0, 0 },  
                { 74, 73, 69, 0, 0, 0 }, { 74, 73, 78, 0, 0, 0 },  
                { 74, 73, 78, 71, 0, 0 }, { 74, 73, 79, 78, 71, 0 },  
                { 74, 73, 85, 0, 0, 0 }, { 74, 85, 0, 0, 0, 0 },  
                { 74, 85, 65, 78, 0, 0 }, { 74, 85, 69, 0, 0, 0 },  
                { 74, 85, 78, 0, 0, 0 }, { 75, 65, 0, 0, 0, 0 },  
                { 75, 65, 73, 0, 0, 0 }, { 75, 65, 78, 0, 0, 0 },  
                { 75, 65, 78, 71, 0, 0 }, { 75, 65, 79, 0, 0, 0 },  
                { 75, 69, 0, 0, 0, 0 }, { 75, 69, 78, 0, 0, 0 },  
                { 75, 69, 78, 71, 0, 0 }, { 75, 79, 78, 71, 0, 0 },  
                { 75, 79, 85, 0, 0, 0 }, { 75, 85, 0, 0, 0, 0 },  
                { 75, 85, 65, 0, 0, 0 }, { 75, 85, 65, 73, 0, 0 },  
                { 75, 85, 65, 78, 0, 0 }, { 75, 85, 65, 78, 71, 0 },  
                { 75, 85, 73, 0, 0, 0 }, { 75, 85, 78, 0, 0, 0 },  
                { 75, 85, 79, 0, 0, 0 }, { 76, 65, 0, 0, 0, 0 },  
                { 76, 65, 73, 0, 0, 0 }, { 76, 65, 78, 0, 0, 0 },  
                { 76, 65, 78, 71, 0, 0 }, { 76, 65, 79, 0, 0, 0 },  
                { 76, 69, 0, 0, 0, 0 }, { 76, 69, 73, 0, 0, 0 },  
                { 76, 69, 78, 71, 0, 0 }, { 76, 73, 0, 0, 0, 0 },  
                { 76, 73, 65, 0, 0, 0 }, { 76, 73, 65, 78, 0, 0 },  
                { 76, 73, 65, 78, 71, 0 }, { 76, 73, 65, 79, 0, 0 },  
                { 76, 73, 69, 0, 0, 0 }, { 76, 73, 78, 0, 0, 0 },  
                { 76, 73, 78, 71, 0, 0 }, { 76, 73, 85, 0, 0, 0 },  
                { 76, 79, 0, 0, 0, 0 }, { 76, 79, 78, 71, 0, 0 },  
                { 76, 79, 85, 0, 0, 0 }, { 76, 85, 0, 0, 0, 0 },  
                { 76, 85, 65, 78, 0, 0 }, { 76, 85, 69, 0, 0, 0 },  
                { 76, 85, 78, 0, 0, 0 }, { 76, 85, 79, 0, 0, 0 },  
                { 77, 0, 0, 0, 0, 0 }, { 77, 65, 0, 0, 0, 0 },  
                { 77, 65, 73, 0, 0, 0 }, { 77, 65, 78, 0, 0, 0 },  
                { 77, 65, 78, 71, 0, 0 }, { 77, 65, 79, 0, 0, 0 },  
                { 77, 69, 0, 0, 0, 0 }, { 77, 69, 73, 0, 0, 0 },  
                { 77, 69, 78, 0, 0, 0 }, { 77, 69, 78, 71, 0, 0 },  
                { 77, 73, 0, 0, 0, 0 }, { 77, 73, 65, 78, 0, 0 },  
                { 77, 73, 65, 79, 0, 0 }, { 77, 73, 69, 0, 0, 0 },  
                { 77, 73, 78, 0, 0, 0 }, { 77, 73, 78, 71, 0, 0 },  
                { 77, 73, 85, 0, 0, 0 }, { 77, 79, 0, 0, 0, 0 },  
                { 77, 79, 85, 0, 0, 0 }, { 77, 85, 0, 0, 0, 0 },  
                { 78, 0, 0, 0, 0, 0 }, { 78, 65, 0, 0, 0, 0 },  
                { 78, 65, 73, 0, 0, 0 }, { 78, 65, 78, 0, 0, 0 },  
                { 78, 65, 78, 71, 0, 0 }, { 78, 65, 79, 0, 0, 0 },  
                { 78, 69, 0, 0, 0, 0 }, { 78, 69, 73, 0, 0, 0 },  
                { 78, 69, 78, 0, 0, 0 }, { 78, 69, 78, 71, 0, 0 },  
                { 78, 73, 0, 0, 0, 0 }, { 78, 73, 65, 78, 0, 0 },  
                { 78, 73, 65, 78, 71, 0 }, { 78, 73, 65, 79, 0, 0 },  
                { 78, 73, 69, 0, 0, 0 }, { 78, 73, 78, 0, 0, 0 },  
                { 78, 73, 78, 71, 0, 0 }, { 78, 73, 85, 0, 0, 0 },  
                { 78, 79, 78, 71, 0, 0 }, { 78, 79, 85, 0, 0, 0 },  
                { 78, 85, 0, 0, 0, 0 }, { 78, 85, 65, 78, 0, 0 },  
                { 78, 85, 69, 0, 0, 0 }, { 78, 85, 78, 0, 0, 0 },  
                { 78, 85, 79, 0, 0, 0 }, { 79, 0, 0, 0, 0, 0 },  
                { 79, 85, 0, 0, 0, 0 }, { 80, 65, 0, 0, 0, 0 },  
                { 80, 65, 73, 0, 0, 0 }, { 80, 65, 78, 0, 0, 0 },  
                { 80, 65, 78, 71, 0, 0 }, { 80, 65, 79, 0, 0, 0 },  
                { 80, 69, 73, 0, 0, 0 }, { 80, 69, 78, 0, 0, 0 },  
                { 80, 69, 78, 71, 0, 0 }, { 80, 73, 0, 0, 0, 0 },  
                { 80, 73, 65, 78, 0, 0 }, { 80, 73, 65, 79, 0, 0 },  
                { 80, 73, 69, 0, 0, 0 }, { 80, 73, 78, 0, 0, 0 },  
                { 80, 73, 78, 71, 0, 0 }, { 80, 79, 0, 0, 0, 0 },  
                { 80, 79, 85, 0, 0, 0 }, { 80, 85, 0, 0, 0, 0 },  
                { 81, 73, 0, 0, 0, 0 }, { 81, 73, 65, 0, 0, 0 },  
                { 81, 73, 65, 78, 0, 0 }, { 81, 73, 65, 78, 71, 0 },  
                { 81, 73, 65, 79, 0, 0 }, { 81, 73, 69, 0, 0, 0 },  
                { 81, 73, 78, 0, 0, 0 }, { 81, 73, 78, 71, 0, 0 },  
                { 81, 73, 79, 78, 71, 0 }, { 81, 73, 85, 0, 0, 0 },  
                { 81, 85, 0, 0, 0, 0 }, { 81, 85, 65, 78, 0, 0 },  
                { 81, 85, 69, 0, 0, 0 }, { 81, 85, 78, 0, 0, 0 },  
                { 82, 65, 78, 0, 0, 0 }, { 82, 65, 78, 71, 0, 0 },  
                { 82, 65, 79, 0, 0, 0 }, { 82, 69, 0, 0, 0, 0 },  
                { 82, 69, 78, 0, 0, 0 }, { 82, 69, 78, 71, 0, 0 },  
                { 82, 73, 0, 0, 0, 0 }, { 82, 79, 78, 71, 0, 0 },  
                { 82, 79, 85, 0, 0, 0 }, { 82, 85, 0, 0, 0, 0 },  
                { 82, 85, 65, 0, 0, 0 }, { 82, 85, 65, 78, 0, 0 },  
                { 82, 85, 73, 0, 0, 0 }, { 82, 85, 78, 0, 0, 0 },  
                { 82, 85, 79, 0, 0, 0 }, { 83, 65, 0, 0, 0, 0 },  
                { 83, 65, 73, 0, 0, 0 }, { 83, 65, 78, 0, 0, 0 },  
                { 83, 65, 78, 71, 0, 0 }, { 83, 65, 79, 0, 0, 0 },  
                { 83, 69, 0, 0, 0, 0 }, { 83, 69, 78, 0, 0, 0 },  
                { 83, 69, 78, 71, 0, 0 }, { 83, 72, 65, 0, 0, 0 },  
                { 83, 72, 65, 73, 0, 0 }, { 83, 72, 65, 78, 0, 0 },  
                { 83, 72, 65, 78, 71, 0 }, { 83, 72, 65, 79, 0, 0 },  
                { 83, 72, 69, 0, 0, 0 }, { 83, 72, 69, 78, 0, 0 },  
                { 88, 73, 78, 0, 0, 0 }, { 83, 72, 69, 78, 0, 0 },  
                { 83, 72, 69, 78, 71, 0 }, { 83, 72, 73, 0, 0, 0 },  
                { 83, 72, 79, 85, 0, 0 }, { 83, 72, 85, 0, 0, 0 },  
                { 83, 72, 85, 65, 0, 0 }, { 83, 72, 85, 65, 73, 0 },  
                { 83, 72, 85, 65, 78, 0 }, { 83, 72, 85, 65, 78, 71 },  
                { 83, 72, 85, 73, 0, 0 }, { 83, 72, 85, 78, 0, 0 },  
                { 83, 72, 85, 79, 0, 0 }, { 83, 73, 0, 0, 0, 0 },  
                { 83, 79, 78, 71, 0, 0 }, { 83, 79, 85, 0, 0, 0 },  
                { 83, 85, 0, 0, 0, 0 }, { 83, 85, 65, 78, 0, 0 },  
                { 83, 85, 73, 0, 0, 0 }, { 83, 85, 78, 0, 0, 0 },  
                { 83, 85, 79, 0, 0, 0 }, { 84, 65, 0, 0, 0, 0 },  
                { 84, 65, 73, 0, 0, 0 }, { 84, 65, 78, 0, 0, 0 },  
                { 84, 65, 78, 71, 0, 0 }, { 84, 65, 79, 0, 0, 0 },  
                { 84, 69, 0, 0, 0, 0 }, { 84, 69, 78, 71, 0, 0 },  
                { 84, 73, 0, 0, 0, 0 }, { 84, 73, 65, 78, 0, 0 },  
                { 84, 73, 65, 79, 0, 0 }, { 84, 73, 69, 0, 0, 0 },  
                { 84, 73, 78, 71, 0, 0 }, { 84, 79, 78, 71, 0, 0 },  
                { 84, 79, 85, 0, 0, 0 }, { 84, 85, 0, 0, 0, 0 },  
                { 84, 85, 65, 78, 0, 0 }, { 84, 85, 73, 0, 0, 0 },  
                { 84, 85, 78, 0, 0, 0 }, { 84, 85, 79, 0, 0, 0 },  
                { 87, 65, 0, 0, 0, 0 }, { 87, 65, 73, 0, 0, 0 },  
                { 87, 65, 78, 0, 0, 0 }, { 87, 65, 78, 71, 0, 0 },  
                { 87, 69, 73, 0, 0, 0 }, { 87, 69, 78, 0, 0, 0 },  
                { 87, 69, 78, 71, 0, 0 }, { 87, 79, 0, 0, 0, 0 },  
                { 87, 85, 0, 0, 0, 0 }, { 88, 73, 0, 0, 0, 0 },  
                { 88, 73, 65, 0, 0, 0 }, { 88, 73, 65, 78, 0, 0 },  
                { 88, 73, 65, 78, 71, 0 }, { 88, 73, 65, 79, 0, 0 },  
                { 88, 73, 69, 0, 0, 0 }, { 88, 73, 78, 0, 0, 0 },  
                { 88, 73, 78, 71, 0, 0 }, { 88, 73, 79, 78, 71, 0 },  
                { 88, 73, 85, 0, 0, 0 }, { 88, 85, 0, 0, 0, 0 },  
                { 88, 85, 65, 78, 0, 0 }, { 88, 85, 69, 0, 0, 0 },  
                { 88, 85, 78, 0, 0, 0 }, { 89, 65, 0, 0, 0, 0 },  
                { 89, 65, 78, 0, 0, 0 }, { 89, 65, 78, 71, 0, 0 },  
                { 89, 65, 79, 0, 0, 0 }, { 89, 69, 0, 0, 0, 0 },  
                { 89, 73, 0, 0, 0, 0 }, { 89, 73, 78, 0, 0, 0 },  
                { 89, 73, 78, 71, 0, 0 }, { 89, 79, 0, 0, 0, 0 },  
                { 89, 79, 78, 71, 0, 0 }, { 89, 79, 85, 0, 0, 0 },  
                { 89, 85, 0, 0, 0, 0 }, { 89, 85, 65, 78, 0, 0 },  
                { 89, 85, 69, 0, 0, 0 }, { 89, 85, 78, 0, 0, 0 },  
                { 74, 85, 78, 0, 0, 0 }, { 89, 85, 78, 0, 0, 0 },  
                { 90, 65, 0, 0, 0, 0 }, { 90, 65, 73, 0, 0, 0 },  
                { 90, 65, 78, 0, 0, 0 }, { 90, 65, 78, 71, 0, 0 },  
                { 90, 65, 79, 0, 0, 0 }, { 90, 69, 0, 0, 0, 0 },  
                { 90, 69, 73, 0, 0, 0 }, { 90, 69, 78, 0, 0, 0 },  
                { 90, 69, 78, 71, 0, 0 }, { 90, 72, 65, 0, 0, 0 },  
                { 90, 72, 65, 73, 0, 0 }, { 90, 72, 65, 78, 0, 0 },  
                { 90, 72, 65, 78, 71, 0 }, { 67, 72, 65, 78, 71, 0 },  
                { 90, 72, 65, 78, 71, 0 }, { 90, 72, 65, 79, 0, 0 },  
                { 90, 72, 69, 0, 0, 0 }, { 90, 72, 69, 78, 0, 0 },  
                { 90, 72, 69, 78, 71, 0 }, { 90, 72, 73, 0, 0, 0 },  
                { 83, 72, 73, 0, 0, 0 }, { 90, 72, 73, 0, 0, 0 },  
                { 90, 72, 79, 78, 71, 0 }, { 90, 72, 79, 85, 0, 0 },  
                { 90, 72, 85, 0, 0, 0 }, { 90, 72, 85, 65, 0, 0 },  
                { 90, 72, 85, 65, 73, 0 }, { 90, 72, 85, 65, 78, 0 },  
                { 90, 72, 85, 65, 78, 71 }, { 90, 72, 85, 73, 0, 0 },  
                { 90, 72, 85, 78, 0, 0 }, { 90, 72, 85, 79, 0, 0 },  
                { 90, 73, 0, 0, 0, 0 }, { 90, 79, 78, 71, 0, 0 },  
                { 90, 79, 85, 0, 0, 0 }, { 90, 85, 0, 0, 0, 0 },  
                { 90, 85, 65, 78, 0, 0 }, { 90, 85, 73, 0, 0, 0 },  
                { 90, 85, 78, 0, 0, 0 }, { 90, 85, 79, 0, 0, 0 },  
                { 0, 0, 0, 0, 0, 0 }, { 83, 72, 65, 78, 0, 0 },  
                { 0, 0, 0, 0, 0, 0 }, };  
      
        /** 
         * First and last Chinese character with known Pinyin according to zh 
         * collation 
         */  
        private static final String FIRST_PINYIN_UNIHAN = "\u963F";  
        private static final String LAST_PINYIN_UNIHAN = "\u9FFF";  
      
        private static final Collator COLLATOR = Collator.getInstance(Locale.CHINA);  
      
        private static HanziToPinyin sInstance;  
        private final boolean mHasChinaCollator;  
      
        public static class Token {  
            /** 
             * Separator between target string for each source char 
             */  
            public static final String SEPARATOR = " ";  
      
            public static final int LATIN = 1;  
            public static final int PINYIN = 2;  
            public static final int UNKNOWN = 3;  
      
            public Token() {  
            }  
      
            public Token(int type, String source, String target) {  
                this.type = type;  
                this.source = source;  
                this.target = target;  
            }  
      
            /** 
             * Type of this token, ASCII, PINYIN or UNKNOWN. 
             */  
            public int type;  
            /** 
             * Original string before translation. 
             */  
            public String source;  
            /** 
             * Translated string of source. For Han, target is corresponding Pinyin. 
             * Otherwise target is original string in source. 
             */  
            public String target;  
        }  
      
        protected HanziToPinyin(boolean hasChinaCollator) {  
            mHasChinaCollator = hasChinaCollator;  
        }  
      
        public static HanziToPinyin getInstance() {  
            synchronized (HanziToPinyin.class) {  
                if (sInstance != null) {  
                    return sInstance;  
                }  
                // Check if zh_CN collation data is available  
                final Locale locale[] = Collator.getAvailableLocales();  
      
                // 增加的代码,增强。  
                final Locale chinaAddition = new Locale("zh");  
      
                for (int i = 0; i < locale.length; i++) {  
                    if (locale[i].equals(Locale.CHINA)  
                            || locale[i].equals(chinaAddition)) {  
                        // Do self validation just once.  
                        if (DEBUG) {  
                            Log.d(TAG, "Self validation. Result: "  
                                    + doSelfValidation());  
                        }  
                        sInstance = new HanziToPinyin(true);  
                        return sInstance;  
                    }  
                }  
                Log.w(TAG,  
                        "There is no Chinese collator, HanziToPinyin is disabled");  
                sInstance = new HanziToPinyin(false);  
                return sInstance;  
            }  
        }  
      
        /** 
         * Validate if our internal table has some wrong value. 
         * 
         * @return true when the table looks correct. 
         */  
        private static boolean doSelfValidation() {  
            char lastChar = UNIHANS[0];  
            String lastString = Character.toString(lastChar);  
            for (char c : UNIHANS) {  
                if (lastChar == c) {  
                    continue;  
                }  
                final String curString = Character.toString(c);  
                int cmp = COLLATOR.compare(lastString, curString);  
                if (cmp >= 0) {  
                    Log.e(TAG, "Internal error in Unihan table. "  
                            + "The last string \"" + lastString  
                            + "\" is greater than current string \"" + curString  
                            + "\".");  
                    return false;  
                }  
                lastString = curString;  
            }  
            return true;  
        }  
      
        private Token getToken(char character) {  
            Token token = new Token();  
            final String letter = Character.toString(character);  
            token.source = letter;  
            int offset = -1;  
            int cmp;  
            if (character < 256) {  
                token.type = Token.LATIN;  
                token.target = letter;  
                return token;  
            } else {  
                cmp = COLLATOR.compare(letter, FIRST_PINYIN_UNIHAN);  
                if (cmp < 0) {  
                    token.type = Token.UNKNOWN;  
                    token.target = letter;  
                    return token;  
                } else if (cmp == 0) {  
                    token.type = Token.PINYIN;  
                    offset = 0;  
                } else {  
                    cmp = COLLATOR.compare(letter, LAST_PINYIN_UNIHAN);  
                    if (cmp > 0) {  
                        token.type = Token.UNKNOWN;  
                        token.target = letter;  
                        return token;  
                    } else if (cmp == 0) {  
                        token.type = Token.PINYIN;  
                        offset = UNIHANS.length - 1;  
                    }  
                }  
            }  
      
            token.type = Token.PINYIN;  
            if (offset < 0) {  
                int begin = 0;  
                int end = UNIHANS.length - 1;  
                while (begin <= end) {  
                    offset = (begin + end) / 2;  
                    final String unihan = Character.toString(UNIHANS[offset]);  
                    cmp = COLLATOR.compare(letter, unihan);  
                    if (cmp == 0) {  
                        break;  
                    } else if (cmp > 0) {  
                        begin = offset + 1;  
                    } else {  
                        end = offset - 1;  
                    }  
                }  
            }  
            if (cmp < 0) {  
                offset--;  
            }  
            StringBuilder pinyin = new StringBuilder();  
            for (int j = 0; j < PINYINS[offset].length && PINYINS[offset][j] != 0; j++) {  
                pinyin.append((char) PINYINS[offset][j]);  
            }  
            token.target = pinyin.toString();  
            if (TextUtils.isEmpty(token.target)) {  
                token.type = Token.UNKNOWN;  
                token.target = token.source;  
            }  
            return token;  
        }  
      
        /** 
         * Convert the input to a array of tokens. The sequence of ASCII or Unknown 
         * characters without space will be put into a Token, One Hanzi character 
         * which has pinyin will be treated as a Token. If these is no China 
         * collator, the empty token array is returned. 
         */  
        public ArrayList<Token> get(final String input) {  
            ArrayList<Token> tokens = new ArrayList<Token>();  
            if (!mHasChinaCollator || TextUtils.isEmpty(input)) {  
                // return empty tokens.  
                return tokens;  
            }  
            final int inputLength = input.length();  
            final StringBuilder sb = new StringBuilder();  
            int tokenType = Token.LATIN;  
            // Go through the input, create a new token when  
            // a. Token type changed  
            // b. Get the Pinyin of current charater.  
            // c. current character is space.  
            for (int i = 0; i < inputLength; i++) {  
                final char character = input.charAt(i);  
                if (character == ' ') {  
                    if (sb.length() > 0) {  
                        addToken(sb, tokens, tokenType);  
                    }  
                } else if (character < 256) {  
                    if (tokenType != Token.LATIN && sb.length() > 0) {  
                        addToken(sb, tokens, tokenType);  
                    }  
                    tokenType = Token.LATIN;  
                    sb.append(character);  
                } else {  
                    Token t = getToken(character);  
                    if (t.type == Token.PINYIN) {  
                        if (sb.length() > 0) {  
                            addToken(sb, tokens, tokenType);  
                        }  
                        tokens.add(t);  
                        tokenType = Token.PINYIN;  
                    } else {  
                        if (tokenType != t.type && sb.length() > 0) {  
                            addToken(sb, tokens, tokenType);  
                        }  
                        tokenType = t.type;  
                        sb.append(character);  
                    }  
                }  
            }  
            if (sb.length() > 0) {  
                addToken(sb, tokens, tokenType);  
            }  
            return tokens;  
        }  
      
        private void addToken(final StringBuilder sb,  
                final ArrayList<Token> tokens, final int tokenType) {  
            String str = sb.toString();  
            tokens.add(new Token(tokenType, str, str));  
            sb.setLength(0);  
        }  
    }  

    写一个MainActivity.java测试汉字转化为汉语拼音输出的效果:

    package zhangphil.hanyupinyin;  
      
    import java.util.ArrayList;  
      
    import zhangphil.hanyupinyin.HanziToPinyin.Token;  
    import android.app.Activity;  
    import android.os.Bundle;  
      
    public class MainActivity extends Activity {  
      
        @Override  
        protected void onCreate(Bundle savedInstanceState) {  
            super.onCreate(savedInstanceState);  
      
            String s = "安卓";  
            System.out.println("汉字转拼音输出: " + getPinYin(s));  
        }  
      
        // 输入汉字返回拼音的通用方法函数。  
        public static String getPinYin(String hanzi) {  
            ArrayList<Token> tokens = HanziToPinyin.getInstance().get(hanzi);  
            StringBuilder sb = new StringBuilder();  
            if (tokens != null && tokens.size() > 0) {  
                for (Token token : tokens) {  
                    if (Token.PINYIN == token.type) {  
                        sb.append(token.target);  
                    } else {  
                        sb.append(token.source);  
                    }  
                }  
            }  
      
            return sb.toString().toUpperCase();  
        }  
    }  

    结果输出如图:

    原文

    展开全文
  • 语音识别,语音合成。语音技术主要分两块:一块是语音文字,即语音识别;... 应用场景:在线语音合成、离线语音合成系统场景- 读故事,小说频道,读新闻(新闻中的语音播报)。声学行业.。 智能音箱大战全面开...

      语音识别,语音合成语音技术主要分两块:一块是语音转文字,即语音识别;另一块是文字转语音,即语音合成。
      语音相关技术研发 语音合成技术整体解决方案。一系列语音技术的相关专利,包括文本处理、韵律预测、声学模型、拼接系统、模型自适应、神经网络、情感合成等多个方面。
      应用场景:在线语音合成、离线语音合成系统场景- 读故事,小说频道,读新闻(新闻中的语音播报)。声学行业.。
    智能音箱大战全面开火- http://blog.csdn.net/dqcfkyqdxym3f8rb0/article/details/78574066

      Librispeech是当前衡量语音识别技术的最权威主流的开源数据集。错词率(Worderrorrate,WER)是衡量语音识别技术水平的核心指标。近日,云从科技在Librispeech数据集上将错词率(Worderrorrate,WER)降到了2.97%,较之前提升了25%。超过阿里、百度、约翰霍普金斯大学等企业及高校,大幅刷新原先记录。

      tts识别,合成,播放。
    -- 支付宝的语音收款方案为:文字已经录好在文件中

    Android支付宝商家收款语音播报(无SDK)- https://www.jianshu.com/p/62e6382c610b

    支付宝商家语音播报- https://github.com/YzyCoding/PushVoiceBroadcast

    -- 变声:萝莉/大叔/卖萌/搞笑等

    Android QQ变声特效例子- https://github.com/huanglinqing123/ChangeVoice/tree/master 
     在QQ中我们使用到的一个功能就是变声,QQ是使用FMOD实现的,那么同样的我们也使用FMOD让自己的应用可以变音。
     fmod Ex 声音系统是为游戏开发者准备的革命性音频引擎,链接:https://pan.baidu.com/s/1TW3ctQd0o5bOVCx5gKL0hA 密码:x2o4 。 fmod声音系统是为游戏开发者准备的革命性音频引擎,如今采用了fmod作为音频引擎的游戏包括Far Cry(孤岛惊魂)、Tom Clancy's Ghost Recon(幽灵行动),甚至著名的World Of Warcraft(魔兽争霸)。
    仿QQ语音变声功能实现- https://github.com/CN-ZPH/MySound https://github.com/fsrmeng/VoiceChange https://github.com/Android-LiuHuan/MyVoice

    > 语音识别(ASR)与语音合成服务(TTS)
      语音识别(ASR)、语音合成(TTS)、语义理解(NLP)等技术。
    语音识别ASR技术通识- https://blog.csdn.net/ZLJ925/article/details/79045034
    MRCP协议-提供语音识别(ASR)与语音合成服务(TTS)-https://blog.51cto.com/chenwen/1434915

      语音识别技术(ASR)——将人说话的语音信号转换为可被计算机识别的文字信息,从而识别说话人的语音指令以及文字内容的技术。
      语音合成技术(TTS)——将文字信息转变为语音数据,以语音的方式播放出来的技术。
      TTS,英文全称是TextToSpeech,即文语转换,又称为计算机语音合成,它的过程和ASR刚好相反,是把计算机中任意出现的文字转换成自然流畅的语音输出。一般认为,语音合成系统包括三个主要的组成部分:文本分析模块、韵律生成模块和声学模块。目前,TTS的技术已经可以达到商业化的地步。

    -- MRCP
       媒体资源控制协议(Media Resource Control Protocol,MRCP)是由Cisco、Nuance等公司联合开发的网络协议,该协议由IETF作为Internet草案发布(draft-shanmugham-mrcp-07)。该协议为那些需要进行语音处理的客户端提供了一种通过网络来控制媒体处理资源(如ASR、TTS引擎等)的机制。该协议在设计之初就考虑了可以在将来得到扩展以支持声纹鉴别和身份识别(Speaker Identification/Speaker Verification)等功能。 
      媒体资源控制协议(Media Resource Control Protocol, MRCP)是一种通讯协议,用于语音服务器向客户端提供各种语音服务(如语音识别和语音合成)。
      MRCP并不定义会话连接,不关心服务器与客户端是如何连接的,MRCP的消息通常是承载于其它协议之上,如RTSP,SIP等。
     MRCP消息使用类似于HTTP等许多Internet协议一样的文本格式,每个消息包括三部分:首行,消息头,消息体。首行表明消息类型及返回码等信息。消息头包括了若干行内容,每一行都形如 "字段名:数值"。消息体包括了消息的详细内容,长度在消息头中指定。
     随着MRCP协议的不断推广与应用,各语音技术厂商在实践与部署过程中碰到了各种各样的问题。为此,IESG(The Internet Engineering Steering Group)于2002年特许成立了Speechsc工作组,专门负责起草更加完善高效的支持分布式语音资源处理的开放协议。在Speechsc工作组的努力下,改进后的MRCPv2(draft-ietf-speechsc-mrcpv2-09)很快应运而生了。MRCPv2的消息格式和资源状态机等都建立在MRCP协议版本1的基础之上,它完全兼容W3C的SSML、SRGS、NLSML标准。与MRCPv1不同的是MRCPv2消息不再依赖RTSP作为载体,而是作为独立的消息进行传输,但是它仍依赖于会话管理协议,如SIP(Session Initiation Protocol)协议,来在客户端与服务器端之间建立控制会话。 
     MRCP设计的特定目标很明确,就是为那些采用不同厂商的ASR和TTS产品来构建IVR或消息类应用的开发商提供便利。

    -- 主流语音技术
    目前国外几乎所有的主流语音技术供应商都已经宣布推出基于MRCPv1的产品:
     ● 语音资源供应商:Acapela、BBN、IBM、Loquendo、Nuance(ScanSoft)、Rhetorical、Telisma等;
     ● 板卡技术供应商:Intel、NMS、Aculab等;
     ● 语音技术应用集成商:Cisco、Nortel、Lucent、HP、Edify、Genesys、Intervoice、SER、Unisys、Convedia等。 
      市场上有很多比较成熟的语音ASR和TTS产品,而且他们大多数都支持二次开发,如微软的Speech Application SDK(SASDK)、IBM的Dutty++等。他们能识别(生成)英语、日语和中文等不同国家的语言,Dutty++甚至能够识别某些地区的方言,如广东的方言-粤语。
      科大讯飞、百度语音、捷通华声、云知声等。阿里云语音识别。
      微软SAPI将ASR和TTS功能集成在同一个语音引擎中,TTS可以将文本和文件合成为语音,ASR则是将人的声音信号转换为可读的文本或文件。

      语音识别(Automatic Speech Recognition),一般简称ASR;是将声音转化为文字的过程,相当于人类的耳朵。
      语音识别原理流程:“输入——编码——解码——输出”
      语音识别,大体可分为“传统”识别方式与“端到端”识别方式,其主要差异就体现在声学模型上。“传统”方式的声学模型一般采用隐马尔可夫模型(HMM),而“端到端”方式一般采用深度神经网络(DNN)。
      远场语音识别,简称远场识别,口语中可更简化为“远场”。下面主要说3个概念:语音激活检测、语音唤醒、以及麦克风阵列。

     iphone 6s 语音激活的低功耗芯片.按麦克风个数分:单麦、双麦、多麦 .
     车内语音识别的难点很多,除了多人说话的干扰,还有胎噪、风噪,以及经常处于离线情况。 

      语音识别系统的性能大致取决于以下4类因素:1. 识别词汇表的大小和语音的复杂性;2. 语音信号的质量;3. 单个说话人还是多说话人;4. 硬件。

      媒体采集设备主要用来采集各种语音信号,如对普通的电信网,就是PCM a律信号的采集;而对VOIP应用,采集的信号可能有很多种,包括G.711/G.723/G.729等各种语音格式。同时,该设备还需要具备一定的媒体转换能力,能将各种媒体流转换为ASR能够识别的语音格式。
      语音识别是一个多学科交叉的领域,它与声学、语音学、语言学、数字信号处理理论、信息论、计算机科学等众多学科紧密相连。
      TTS的技术实现方法,主要有2种:“拼接法”和“参数法”。

      语音识别主要识别框架:基于模式匹配的动态时间规整法(DTW)和基于统计模型的隐马尔可夫模型法(HMM)。

    https://img-blog.csdnimg.cn/20190511215006499.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1NoYXJlVXM=,size_16,color_FFFFFF,t_70

    > 汉字转拼音(ASCII码映射等)
    Android 汉字转拼音的多种实现方式- http://blog.csdn.net/zhuwentao2150/article/details/70230341?ref=myread
    利用Android源码,轻松实现汉字转拼音功能- http://blog.csdn.net/D_clock/article/details/69890954

    HanziToPinyin(汉字转拼音)- https://gist.github.com/D-clock/7a6e33f42c0177439a49d85b73f1e600

    jpinyin- https://github.com/stuxuhai/jpinyin

     -- Android平台上将汉字转换成为拼音已经有一些开源的第三方实现方案,如pinyin4j和TinyPinyin
    TinyPinyin:https://github.com/promeG/TinyPinyin
       建立一个大的对照表(比如用关联容器Map),同时一个汉字可能有多个发音,也就是说Map这样的容器时不行的,因为其<key,value>必须是一一对应的。在C++中可以用STL里面的multimap来解决这个问题,但Java中没有类似multimap这样的东西,除非自己实现一个。pinyin4j(将汉字转化为拼音):https://sourceforge.net/projects/pinyin4j .
    Pinyin4j(http://pinyin4j.sourceforge.net/)就是为了解决类似这样的问题的。它是sourceforge.net上的一个开源项目,功能非常强大:
     1.支持同一汉字有多个发音
     2.还支持拼音的格式化输出,比如第几声之类的,
     3.同时支持简体中文、繁体中文转换为拼音…使用起来也非常简单。> TTS

    -- 汉语拼音开源:tinypinyin, pinyin4j
    城市demo--  http://github.com/18722527635/CityDemo

    > 语音识别引擎
    Android中文语音合成(TTS)各家引擎对比- http://blog.csdn.net/yao_guet/article/details/7231489/
    Android 文本转语音TextToSpeech (TTS)- http://blog.csdn.net/zhoumushui/article/details/50496661
    【Android语音合成TTS】国内主流引擎对比- http://blog.csdn.net/fengyuzhengfan/article/details/45052823
    -- 五款免费开源的语音识别工具- https://blog.csdn.net/godloveyuxu/article/details/77416017
      直到几年之前,最先进的语音技术方案大多都是以语音为基础的(phonetic-based),包括发音模型(Pronunciation models),声学模型(Acoustic Modelling)和语言模型(Language Model)等。通常情况下,这些模型大多都是以隐马尔可夫模型(HMM)和 N-gram 模型为核心的。
      五款基于 HMM 和 N-gram 模型的语音识别工具:CMU Sphinx,Kaldi,HTK,Julius 和 ISIP。它们都是开源世界的顶级项目,与 Dragon 和 Cortana 等商业语音识别工具不同
      基于 Julius 的语音识别样例- https://github.com/julius-speech/dictation-kit 
      18 个开源翻译工具帮助你的项目本地化- https://blog.csdn.net/hj7jay/article/details/74171368

    -- 常见的语音sdk主要有:科大讯飞、百度语音、捷通华声、云知声等 手说TTS;讯飞的语音识别/百度语音识别
     Google Cloud API,百度,科大讯飞的都是初期免费,量大收费.
     JAVA SPEECH 和 SPHINX 等实现方式, 语音引擎(TTS引擎) IBM以前那个语音识别;
     到google上去搜索iris.TTS,就是语音转文本, 其中涉及的语音采样(本地,方言,外语等等)识别技术,在国内有科大讯飞和捷通比较有名,在国外有一个叫luance公司比较有名 。
    > Android中文语音合成引擎的设计与实现,及在Android上应用

    Google的TTS对中文不支持,支持英文。
    android自带的类,从文本中合成语音,用于立即播放或创建一个声音文件.中文的话,需要手机系统有安装中文引擎吧
    https://developer.android.google.cn/reference/android/speech/tts/TextToSpeech.html
    https://github.com/SolveBugs/Utils
    TTS文字转语音并朗读- https://github.com/codestravel/CT_Android_demos/tree/master/CT_Text2SpeechDemo
    android 文字转语音 tts 实现 支持中文 - http://download.csdn.net/download/kingda008/7570591
    TTS_library_stub_3.0_market.jar-  http://download.csdn.net/download/seamless_yang/6996789
    Android TTS说中文- http://blog.csdn.net/true100/article/details/50864247
    开源google框架提供了中文TTS功能- http://code.google.com/p/eyes-free/

    展开全文
  • 例如:在Android手机应用开发中,要查询联系人的姓名,通常都是用拼音进行查询的。 Pinyin4j是一个功能强悍的汉语拼音工具包,是sourceforge.net上的一个开源项目。 主要的功能有: - 支持同一汉字有多个发音 - ...
  • 基于trie树的中文拼音输入法的研究与实现,雷宇,,中文输入法是指为了将汉字输入计算机或手机等电子设备而采用的编码方法,是中文信息处理的重要技术,是电脑中的必备软件。在PC平�
  • 中文简易数字输入法 12.85 应用版  更新版含数字,数码,三码等11种输入!永久免费可用,注册授权永久方便好用!  用简音输入,字均上屏仅2键,比搜狗快!打五笔更快!用三码盲打,比五笔还快!  用内含简音音...
  • 为了满足不同人群需求, 拼音点读机现有电脑版和手机版两个版本自由选择,账号通用,不限制电脑和手机的台数,随时随地,想学就学。 易简学拼音点读机软件功能 ·单个声母、韵母、整体认读音节的发音; ·声母 ...
  • 前言在软件中方便用户查找信息时,都会用到输拼音首字母的简写快速过滤,所以一般我们在Oracle的表中会加上一列助记符列,今天我们就看看将中文怎么转换为拼音首字母。实现方式通过oracle...

    前言

    在软件中方便用户查找信息时,都会用到输拼音首字母的简写快速过滤,所以一般我们在Oracle的表中会加上一列助记符列,今天我们就看看将中文怎么转换为拼音首字母。

    实现方式

    1. 通过oracle的NLSSORT函数对汉字按照拼音排序。

    2. 然后根据汉字的区间返回对应的首字母。

    函数代码

    /* 获取拼音简码函数 */
    CREATE OR REPLACE FUNCTION GET_PYJM (P_NAME IN VARCHAR2)
        RETURN VARCHAR2
    AS
        V_COMPARE   VARCHAR2 (100);
        V_RETURN    VARCHAR2 (4000);
    BEGIN
        DECLARE
            FUNCTION F_NLSSORT (P_WORD IN VARCHAR2)
                RETURN VARCHAR2
            AS
            BEGIN
                RETURN NLSSORT (P_WORD, 'NLS_SORT=SCHINESE_PINYIN_M');
            END;
        BEGIN
            FOR I IN 1 .. LENGTH (P_NAME)
            LOOP
                V_COMPARE := F_NLSSORT (SUBSTR (P_NAME, I, 1));
     
                IF     V_COMPARE >= F_NLSSORT ('吖')
                   AND V_COMPARE <= F_NLSSORT ('驁')
                THEN
                    V_RETURN := V_RETURN || 'A';
                ELSIF     V_COMPARE >= F_NLSSORT ('八')
                      AND V_COMPARE <= F_NLSSORT ('簿')
                THEN
                    V_RETURN := V_RETURN || 'B';
                ELSIF     V_COMPARE >= F_NLSSORT ('嚓')
                      AND V_COMPARE <= F_NLSSORT ('錯')
                THEN
                    V_RETURN := V_RETURN || 'C';
                ELSIF     V_COMPARE >= F_NLSSORT ('咑')
                      AND V_COMPARE <= F_NLSSORT ('鵽')
                THEN
                    V_RETURN := V_RETURN || 'D';
                ELSIF     V_COMPARE >= F_NLSSORT ('妸')
                      AND V_COMPARE <= F_NLSSORT ('樲')
                THEN
                    V_RETURN := V_RETURN || 'E';
                ELSIF     V_COMPARE >= F_NLSSORT ('发')
                      AND V_COMPARE <= F_NLSSORT ('猤')
                THEN
                    V_RETURN := V_RETURN || 'F';
                ELSIF     V_COMPARE >= F_NLSSORT ('旮')
                      AND V_COMPARE <= F_NLSSORT ('腂')
                THEN
                    V_RETURN := V_RETURN || 'G';
                ELSIF     V_COMPARE >= F_NLSSORT ('妎')
                      AND V_COMPARE <= F_NLSSORT ('夻')
                THEN
                    V_RETURN := V_RETURN || 'H';
                ELSIF     V_COMPARE >= F_NLSSORT ('丌')
                      AND V_COMPARE <= F_NLSSORT ('攈')
                THEN
                    V_RETURN := V_RETURN || 'J';
                ELSIF     V_COMPARE >= F_NLSSORT ('咔')
                      AND V_COMPARE <= F_NLSSORT ('穒')
                THEN
                    V_RETURN := V_RETURN || 'K';
                ELSIF     V_COMPARE >= F_NLSSORT ('垃')
                      AND V_COMPARE <= F_NLSSORT ('擽')
                THEN
                    V_RETURN := V_RETURN || 'L';
                ELSIF     V_COMPARE >= F_NLSSORT ('嘸')
                      AND V_COMPARE <= F_NLSSORT ('椧')
                THEN
                    V_RETURN := V_RETURN || 'M';
                ELSIF     V_COMPARE >= F_NLSSORT ('拏')
                      AND V_COMPARE <= F_NLSSORT ('瘧')
                THEN
                    V_RETURN := V_RETURN || 'N';
                ELSIF     V_COMPARE >= F_NLSSORT ('筽')
                      AND V_COMPARE <= F_NLSSORT ('漚')
                THEN
                    V_RETURN := V_RETURN || 'O';
                ELSIF     V_COMPARE >= F_NLSSORT ('妑')
                      AND V_COMPARE <= F_NLSSORT ('曝')
                THEN
                    V_RETURN := V_RETURN || 'P';
                ELSIF     V_COMPARE >= F_NLSSORT ('七')
                      AND V_COMPARE <= F_NLSSORT ('裠')
                THEN
                    V_RETURN := V_RETURN || 'Q';
                ELSIF     V_COMPARE >= F_NLSSORT ('亽')
                      AND V_COMPARE <= F_NLSSORT ('鶸')
                THEN
                    V_RETURN := V_RETURN || 'R';
                ELSIF     V_COMPARE >= F_NLSSORT ('仨')
                      AND V_COMPARE <= F_NLSSORT ('蜶')
                THEN
                    V_RETURN := V_RETURN || 'S';
                ELSIF     V_COMPARE >= F_NLSSORT ('侤')
                      AND V_COMPARE <= F_NLSSORT ('籜')
                THEN
                    V_RETURN := V_RETURN || 'T';
                ELSIF     V_COMPARE >= F_NLSSORT ('屲')
                      AND V_COMPARE <= F_NLSSORT ('鶩')
                THEN
                    V_RETURN := V_RETURN || 'W';
                ELSIF     V_COMPARE >= F_NLSSORT ('夕')
                      AND V_COMPARE <= F_NLSSORT ('鑂')
                THEN
                    V_RETURN := V_RETURN || 'X';
                ELSIF     V_COMPARE >= F_NLSSORT ('丫')
                      AND V_COMPARE <= F_NLSSORT ('韻')
                THEN
                    V_RETURN := V_RETURN || 'Y';
                ELSIF     V_COMPARE >= F_NLSSORT ('帀')
                      AND V_COMPARE <= F_NLSSORT ('咗')
                THEN
                    V_RETURN := V_RETURN || 'Z';
                END IF;
            END LOOP;
     
            RETURN V_RETURN;
        END;
    END; 
    
    
    

    实现效果

    我们直接还是在要导入的数据库中直接先查询出来,然后调用GET_PYJM的函数,上图中nvl(GET_PYJM("SupName“),"SupName")这里用法,因为SupName是我们的中文名称列,如果本身名称是英文那这个获取的数据即为空值了,所以我们直接把空值也直接查询变成SupName的列即可。

    -END-

    Vaccae的往期经典


    OpenCV

    《C++ OpenCV案例实战---卡号获取

    《C++ OpenCV案例实战---卡片截取(附代码)

    《C++ OpenCV透视变换---切换手机正面图片》

    《C++ OpenCV实战---获取数量

    《C++ OpenCV实战---利用颜色分割获取数量》


    Android

    《Android利用SurfaceView结合科大讯飞修改语音实别UI

    《Android关于语音识别的功能实现分析(一)---结构化思维》

    《Android关于语音识别的功能实现分析(二)---语义解析》

    《Android根据类生成签名字符串

    《Android碎片化布局fragment的实战应用

    《Android中RecyclerView嵌套RecyclerView

    《Android里用AsyncTask后的接口回调


    .Net C#

    《C#自定义特性(Attribute)讲解与实际应用

    《C#根据类生成签名字符串(附DEMO下载地址)

    《C++创建动态库C#调用》

    《C#与三菱PLC(型号FX2N)串口通讯类


    数据库及其它

    《Oracel存储过程写报表实战》

    《Delphi轮播视频和图片程序(用于双屏显示程序)

    《SQL随机增加销售数据的脚本编写(附脚本下载地址)

    《Oracle通过ODBC连接SQL Server数据库


    长按下方二维码关注微卡智享

    展开全文
  • 专利名称:拼音汉字计算机输入方法计算机技术被列为我国科学技术发展规划的八大重点项目之一,我国的计算机拥有量正以惊人的速度扩展着,计算机的进一步普及和提高有不同地经济和社会的稳定发展,有赖于教育的普及和...
  • java 中文转拼音之pinyin4j

    千次阅读 2014-06-24 13:02:57
    比如在Android手机应用的开发上,要查询联系人的姓名,通常都是用拼音进行查询的。 比如要查询“曹孟德”,就可以输入“cmd”,即“曹孟德”三个汉字拼音“caomengde”各字的首字母。但是怎样才能将“曹孟德”翻译...
  • pinyin4j:拼音汉字的转换实例

    千次阅读 2015-08-28 17:24:09
    比如在Android手机应用的开发上,要查询联系人的姓名,通常都是用拼音进行查询的。比如要查询“曹孟德”,就可以输入“cmd”,即“曹孟德”三个汉字拼音“caomengde”各字的首字母。但是怎样才能将“曹孟德”翻译...
  • 例如:在Android手机应用开发中,要查询联系人的姓名,通常都是用拼音进行查询的。 Pinyin4j是一个功能强悍的汉语拼音工具包,是sourceforge.net上的一个开源项目。 主要的功能有: - 支持同一汉字有多个发音 - ...
  • 语音文字是生活中经常遇到的问题,借助的录音快速几率会议、课堂、讲座等重要场景内容,通过语音文字工具快速整理成文本。既能避免重要内容被遗忘,也能提高工作、学习效率。说实话,市场上不缺乏优秀的语音...
  • 拼音字体

    千次阅读 2021-07-23 03:44:53
    路由器之家网今天精心准备的是《拼音字体》,下面是详解!汉语拼音字母的字体是什么字体呀?小学语文课本上用的汉语拼音字母叫哥特体(Gothic,又称歌德体)。哥特体有古老哥特体和现代哥特体之分。古老的哥特体是西欧...
  • 《《国家开放大学学习指南》计算机应用基础网上作业答案完整版.doc》由会员分享,可免费在线阅读全文,更多与《《国家开放大学学习指南》计算机应用基础网上作业答案完整版》相关文档资源请在帮帮文库(www.woc88.com...
  • 要在安装OpenHarmony标准系统的设备上编辑中文信息,总是需要中文输入法。拼音输入法是最合理的中文输入方法。拼音输入法属于一种编码输入法。其基本实现原理依赖于拼音汉字之间的编码与解码。
  • 科技高速发展,手机电脑已经得到全面普及,人们运用电脑作为沟通工具和获得咨询已经娱乐的方式,但是不是人人对用键盘打字都是很擅长的,尤其是一些年纪比较大的用户,拼音打字法是一种非常迅速和便捷的打字方法,...
  • C++ 中文转拼音 示例
  • 我们的孩子从小就听家长说中文, 也从来没有学过拼音,就能说很多话,认很多字,所以会有一种认识是我们学中文不需要先学拼音,但实际上这是把语言自然教学和语言系统教学的两种方法混淆了。1)只用语言自然教学法...
  • 1. 简单介绍 有时候,需要将汉字编程对应...比如在Android手机应用的开发上,要查询联系人的姓名,通常都是用拼音进行查询的。比如要查询“曹孟德”,就可以输入“cmd”,即“曹孟德”三个汉字拼音“caomengd
  • 同学们在学习俄语的过程中,需要频繁地查生词和输入俄语,俄语输入法必不可少。今天小编就为大家科普下手机如何下载安装俄语输入法。① 安卓系统1 下载“谷歌输入法”第一步:...(常用中文拼音、英语、俄语)2 下载搜...
  • 学1点欧码规则,用A-Z字母打中文汉字拼音,1-4码出字,平均上屏是2.51键. 3 1 2 33 51 4212 5 3 2 2 5 2 51 1113 2 31 5 24 21111 41 同样1句用内含[笔画输入]打字与词上屏字均仅86键/41字符=2.09键/字
  • 摘要:HZ132-64B30是一种采用12×12点阵的小点阵汉字液晶显示模块,该模块内嵌T9拼音输入法并采用标准的UART与控制MCU通信。文中介绍了该模块的性能特点、引脚功能及用户命令,给出了HZ132-64B30的具体应用电路和...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,968
精华内容 2,387
关键字:

下载汉字转拼音手机应用