中文数字转阿拉伯数字
# -*- coding:utf-8 -*-


class Cn2Arabic():

    # 参考https://blog.csdn.net/hexrain/article/details/52790126
    def __init__(self):
        self.cn_nums = {'〇': 0, '一': 1, '二': 2, '三': 3, '四': 4,
                        '五': 5, '六': 6, '七': 7, '八': 8, '九': 9,
                        '零': 0, '壹': 1, '贰': 2, '叁': 3, '肆': 4,
                        '伍': 5, '陆': 6, '柒': 7, '捌': 8, '玖': 9,
                        '貮': 2, '两': 2, }

        self.uint = {'十': 10, '拾': 10,
                     '百': 100, '佰': 100,
                     '千': 1000, '仟': 1000,
                     '万': 10000, '萬': 10000,
                     '亿': 100000000, '億': 100000000,
                     '兆': 1000000000000, }

    def transform(self, zh_nums):
        nums = []
        unit = 1
        for s in reversed(zh_nums):
            if s in self.cn_nums.keys():
                num = self.cn_nums[s] * unit
                nums.append(num)
            else:
                value = self.uint[s]
                if value in (10000, 100000000):
                    nums.append(value)
                    unit = 1
                else:
                    unit = value

        if unit == 10:  # 处理'十一'这种情况
            nums.append(10)

        res, tmp = 0, 0
        for num in reversed(nums):
            if num in (10000, 100000000):
                tmp *= num
                res += tmp
                tmp = 0
            else:
                tmp += num
        res += tmp
        return res


if __name__ == "__main__":
    cn_aribaric = Cn2Arabic()
    test_nums = ['八',
                 '十一',
                 '一百二十三',
                 '一千二百零三',
                 '一万一千一百零一',
                 '十万零三千六百零九',
                 '一百二十三万四千五百六十七',
                 '一千一百二十三万四千五百六十七',
                 '一亿一千一百二十三万四千五百六十七',
                 '一百零二亿五千零一万零一千零三十八']

    for item in test_nums:
        print(cn_aribaric.transform(item))

/// <summary>
/// 阿拉伯数字转换成中文数字
/// </summary>
/// <param name="x"></param>
/// <returns></returns>
public string NumToChinese(string x)
{
    string[] pArrayNum = { "零", "一", "二", "三", "四", "五", "六", "七", "八", "九" };
    //为数字位数建立一个位数组  
    string[] pArrayDigit = { "", "十", "百", "千" };
    //为数字单位建立一个单位数组  
    string[] pArrayUnits = { "", "万", "亿", "万亿" };
    var pStrReturnValue = ""; //返回值  
    var finger = 0; //字符位置指针  
    var pIntM = x.Length % 4; //取模  
    int pIntK;
    if (pIntM > 0)
        pIntK = x.Length / 4 + 1;
    else
        pIntK = x.Length / 4;
    //外层循环,四位一组,每组最后加上单位: ",万亿,",",亿,",",万,"  
    for (var i = pIntK; i > 0; i--)
    {
        var pIntL = 4;
        if (i == pIntK && pIntM != 0)
            pIntL = pIntM;
        //得到一组四位数  
        var four = x.Substring(finger, pIntL);
        var P_int_l = four.Length;
        //内层循环在该组中的每一位数上循环  
        for (int j = 0; j < P_int_l; j++)
        {
            //处理组中的每一位数加上所在的位  
            int n = Convert.ToInt32(four.Substring(j, 1));
            if (n == 0)
            {
                if (j < P_int_l - 1 && Convert.ToInt32(four.Substring(j + 1, 1)) > 0 && !pStrReturnValue.EndsWith(pArrayNum[n]))
                    pStrReturnValue += pArrayNum[n];
            }
            else
            {
                if (!(n == 1 && (pStrReturnValue.EndsWith(pArrayNum[0]) | pStrReturnValue.Length == 0) && j == P_int_l - 2))
                    pStrReturnValue += pArrayNum[n];
                pStrReturnValue += pArrayDigit[P_int_l - j - 1];
            }
        }
        finger += pIntL;
        //每组最后加上一个单位:",万,",",亿," 等  
        if (i < pIntK) //如果不是最高位的一组  
        {
            if (Convert.ToInt32(four) != 0)
                //如果所有4位不全是0则加上单位",万,",",亿,"等  
                pStrReturnValue += pArrayUnits[i - 1];
        }
        else
        {
            //处理最高位的一组,最后必须加上单位  
            pStrReturnValue += pArrayUnits[i - 1];
        }
    }
    return pStrReturnValue;
}

//2.中文数字转阿拉伯数字
/// <summary>
/// 转换数字
/// </summary>
protected static long CharToNumber(char c)
{
    switch (c)
    {
        case '一': return 1;
        case '二': return 2;
        case '三': return 3;
        case '四': return 4;
        case '五': return 5;
        case '六': return 6;
        case '七': return 7;
        case '八': return 8;
        case '九': return 9;
        case '零': return 0;
        default: return -1;
    }
}

/// <summary>
/// 转换单位
/// </summary>
protected static long CharToUnit(char c)
{
    switch (c)
    {
        case '十': return 10;
        case '百': return 100;
        case '千': return 1000;
        case '万': return 10000;
        case '亿': return 100000000;
        default: return 1;
    }
}
/// <summary>
/// 将中文数字转换阿拉伯数字
/// </summary>
/// <param name="cnum">汉字数字</param>
/// <returns>长整型阿拉伯数字</returns>
public static long ParseCnToInt(string cnum)
{
    cnum = Regex.Replace(cnum, "\\s+", "");
    long firstUnit = 1;//一级单位                
    long secondUnit = 1;//二级单位 
    long result = 0;//结果
    for (var i = cnum.Length - 1; i > -1; --i)//从低到高位依次处理
    {
        var tmpUnit = CharToUnit(cnum[i]);//临时单位变量
        if (tmpUnit > firstUnit)//判断此位是数字还是单位
        {
            firstUnit = tmpUnit;//是的话就赋值,以备下次循环使用
            secondUnit = 1;
            if (i == 0)//处理如果是"十","十一"这样的开头的
            {
                result += firstUnit * secondUnit;
            }
            continue;//结束本次循环
        }
        if (tmpUnit > secondUnit)
        {
            secondUnit = tmpUnit;
            continue;
        }
        result += firstUnit * secondUnit * CharToNumber(cnum[i]);//如果是数字,则和单位想乘然后存到结果里
    }
    return result;
}

在使用 《 [Java POI 导出 Excel 文件 异常修复]  》后，为了更加美观，而写的

其中需要将 阿拉伯数字转中文数字 如下代码：

package com.etc.bus.carpark.utils;

import org.springframework.stereotype.Component;

/**
 * 阿拉伯数字转中文数字
 * <p>
 * 
 * @ClassName : IntegerToChineseNumberUtils
 *            </p>
 *            <p>
 * @Description : TODO
 *              </p>
 *              <p>
 * @Author : HuaZai
 *         </p>
 *         <p>
 * @ContactInformation : 1461522031@qq.com/huazai6789@aliyun.com
 *                     </p>
 *                     <p>
 * @Date : 2017年10月26日 下午4:58:50
 *       </p>
 * 
 *       <p>
 * @Version : V1.0.0
 *          </p>
 *
 */
@Component
public class IntegerToChineseNumberUtils {

    /**
     * 获取单位
     * <p>
     * 
     * @Title : ToCH
     *        </p>
     *        <p>
     * @Description : TODO
     *              </p>
     *              <p>
     * @Author : HuaZai
     *         </p>
     *         <p>
     * @Date : 2017年10月26日 下午5:03:05
     *       </p>
     */
    public static String ToCH(int intInput) {
        String si = String.valueOf(intInput);
        String sd = "";
        if (si.length() == 1) { // 个位
            sd += GetCH(intInput);
            return sd;
        } else if (si.length() == 2) { // 十位
            if (si.substring(0, 1).equals("1"))
                sd += "十";
            else
                sd += (GetCH(intInput / 10) + "十");
            sd += ToCH(intInput % 10);
        } else if (si.length() == 3) { // 百位
            sd += (GetCH(intInput / 100) + "百");
            if (String.valueOf(intInput % 100).length() < 2)
                sd += "零";
            sd += ToCH(intInput % 100);
        } else if (si.length() == 4) { // 千位
            sd += (GetCH(intInput / 1000) + "千");
            if (String.valueOf(intInput % 1000).length() < 3)
                sd += "零";
            sd += ToCH(intInput % 1000);
        } else if (si.length() == 5) { // 万位
            sd += (GetCH(intInput / 10000) + "萬");
            if (String.valueOf(intInput % 10000).length() < 4)
                sd += "零";
            sd += ToCH(intInput % 10000);
        }

        return sd;
    }

    /**
     * 获取中文数字
     * <p>
     * 
     * @Title : GetCH
     *        </p>
     *        <p>
     * @Description : TODO
     *              </p>
     *              <p>
     * @Author : HuaZai
     *         </p>
     *         <p>
     * @Date : 2017年10月26日 下午5:03:41
     *       </p>
     */
    private static String GetCH(int input) {
        String sd = "";
        switch (input) {
        case 1:
            sd = "一";
            break;
        case 2:
            sd = "二";
            break;
        case 3:
            sd = "三";
            break;
        case 4:
            sd = "四";
            break;
        case 5:
            sd = "五";
            break;
        case 6:
            sd = "六";
            break;
        case 7:
            sd = "七";
            break;
        case 8:
            sd = "八";
            break;
        case 9:
            sd = "九";
            break;
        default:
            break;
        }
        return sd;
    }
}


以上是关于 阿拉伯数字转中文数字 的解决办法，使用的是普通的 Java 控制流程的方法解决的。 

如果有更好的方法，希望也可以一起分享一下，谢谢！！！

好了，关于 “ 阿拉伯数字转中文数字 ” 就写到这儿； 

也希望大家多多关注CSND的IT社区。

文章目录
中文数字转阿拉伯数字
解题思路
各个击破
友情提醒
阿拉伯数字转中文数字
测试
源码
# 加入战队


阿拉伯数字肯定是使用最广泛的符合之一了。我们日常生活都离不开数字。中文下的数字是中国特色的数字。开发中也会遇到需要两者相互转换的需求。今天就来实现下。

中文数字转阿拉伯数字


想上面的数字一样。假设我们的中文数字是【一亿七千七十九万七千一百九十七】。

解题思路

首先我们需要将上面中文数字按阿拉伯数字进行分离。这里我们先提出一个思想前提： 亿、万  这种是高级单位；千、百、十这种是低级单位。所以我们先按高级单位将上面的进行拆分。



我们得到上面的三个数字。分别是【一亿】、【七千零七十九万】、【七千一百九十七】。下面我们针对这三个数字进行翻译。

各个击破


仔细分析下上面三个中文数字，不难得出结论-上面三个数字去掉高级单位剩下的都只有低级单位了。这也是我们实现的重点【低级单位内的数字转换】


我们将三个数字分别转换完成之后，剩下的就是将他们组合。组合的问题也就是中间补零和去零的操作。


【七千零七十九万】去掉高级单位【七千零七十九】我们翻译也很简单就是将低级单位去掉变成【七零七九】及【7079】。那么上面的三位数字分别是






中文数字
去掉单位后
数字映射




一亿
一
1


七千零七十九万
七零七九
7079


七千一百九十七
七一九七
7197



三位数字翻译好之后我们进行阿拉伯数字的拼接就完成了。 170797197

友情提醒

上面的数字翻译的很是顺利。但是又这么一类数字总是事与愿违。
【一亿零七十九万零一百九十七】==【100790197】
按照上面的思路我们会有如有推理





中文数字
去掉单位后
数字映射




一亿
一
1


零七十九万
零七九
079


零一百九十七
零一九七
0197




根据表格我们拼接得到的数字是【10790197】。这个时候问题就大了去了。我们丢失了一位0。原因也很简单在中文数字中在同一高级单位维度里连续多个零的出现会同一读零。但是阿拉伯数字中确实实实在在的占位的。所以这里就会缺失一位零。


这里的情况是一开始笔者没哟注意到的。但是后来改正了。所以上面提到的合并方法是没有问题的。上面是进行数字化乘以10000的。所以这里的0也不会丢失的。


正确的拼接方案是 ((1*10000)+079)*10000+0197=100790197


这种问题反向过来同样值得注意，在阿拉伯转中文数字的时候我们需要注意0到底代表几个0


阿拉伯数字转中文数字


【100790197】 ==【一亿零七十九万零一百九十七】


【100000197】 ==【一亿零一百九十七】


下面我们将对上面的两个阿拉伯数字进行解析转换。同样我们对他们进行高位分离。这里需要注意的是我们需要从低位到高位方向进行分离





分离是从低位到高位。但是我们转换却要从高位到低位。顺序不能错。在我们阿拉伯数字转中文数字的时候非零数字注解映射转换就行了。但是遇到0的时候我们需要有一下三个条件才能转换，否则就要忽略。

第一次遇到0
数字为0
统一高位单元内后面并不是全是0



简单解释下上面三个。第一个通过一个状态为就能搞定。第二个其实就是保险点。可有可无。最重要第三点遇零后后面不能全是0.这个时候我们才可以将当前位置0翻译成零。


每个非零数字翻译后需要加上低级单位的。


所以上面的0079我们翻译的是【零七十九】


但是零七九并不是真正的汉字数字。所以我们在每一次高位翻译完成之后需要加上高位单位。所以【0079】==【零七十九万】


所以我们得出如下






阿拉伯数字
数字映射




1
一亿


0079
零七十九万


0197
零一百九十七



所以【100790197】 ==【一亿零七十九万零一百九十七】





阿拉伯数字
数字映射




1
一亿


0000



0197
零一百九十七



在加入高级单位时我们需要判断高级单位内数字是否有效。因为我们上面三个原因。所以0000对应的中文数字就是空字符串。这里我们认为是无效中文数字。所以万单位也就没有了。所以【100000197】==【一亿零一百九十七】

测试

光谈理论不讲实践都是扯淡。下面我们需要对我们的设计进行验证。如何验证嗯。好在我们实现的【中文数字转阿拉伯数字】、【阿拉伯数字转中文数字】 。 那么我们直接通过两个方法相互转换。看看最终是不是原来的数据就能验证出来了。话不多说、上代码


Integer right = 0;
Integer total = 10000000;
List<Map<String, Object>> list = new ArrayList<>();
for (int i = 0; i < total; i++) {
    Integer number = MathUtil.getInstance().getRandom(1, 1000000000);
    //System.out.println(i);
    //Integer number = 400001989;
    String chinese = DigitUtil.getInstance().getNumberFromAlabo(number.toString());
    String alabo = DigitUtil.getInstance().getNumberFromChinese(chinese);
    boolean equals = alabo.equals(number.toString());
    if (equals) {
        right++;
    } else {
        Map<String, Object> map  = new HashMap<>();
        map.put("number", number);
        map.put("alabo", alabo);
        map.put("chinese", chinese);
        list.add(map);
    }
}
for (Map<String, Object> map : list) {
    System.out.println(map);
}
System.out.println("成功率："+Double.valueOf(right/(double)total));



测试后的正确率是1 。 也就是0差错。
欢迎指出错误。

源码

package org.zxhtom.utils;

import org.zxhtom.constant.ChineseNumber;

import java.util.*;

/**
 * @package org.zxhtom.utils
 * @Class DigitUtil
 * @Description 数字工具类
 * @Author zhangxinhua
 * @Date 19-7-2 下午3:47
 */
public class DigitUtil {
    private static DigitUtil util;

    public static DigitUtil getInstance() {
        if (null == util) {
            util = new DigitUtil();
        }
        return util;
    }

    /**
     * 中文数字转阿拉伯数字
     *  一万两千三百五十四 --> 12354
     * @param chinese 阿拉伯数字
     * @return 中文数字
     */
    public String getNumberFromChinese(String chinese) {
        String result = "0";
        //将中文数字按四位进行截取。这样每一位里只有单一
        List<String> lists = new ArrayList<>();
        //暂时未使用到
        int lastLevelIndex = 0;
        //循环遍历，目的是将亿万进行分离
        for (int i =  ChineseNumber.highLevel.size()-1; i>=0; i--) {
            //判断亿万单位出现索引
            int levelIndex = chinese.indexOf(ChineseNumber.highLevel.get(i));
            if (levelIndex>0) {
                //表示有单位索引 ， 将单位前数据进行截取装入lists中。后面的继续循环截取
                lists.add(chinese.substring(0, levelIndex));
                chinese = chinese.substring(levelIndex+1);
            } else if (levelIndex == -1) {
                //表示已经是最低单位了，不超过万。直接加入lists中 ， 这里情况对应的是高位分离后，次高位开头是0的情况
                lists.add(ChineseNumber.number.get(0));
            } else if (levelIndex == 0) {
                while (levelIndex > 1) {
                    levelIndex--;
                    lists.add(ChineseNumber.number.get(0));
                }
                //直接加入
                lists.add(chinese);
            }
        }
        //针对分离的四位数据，进行单独翻译
        for (int i = 0; i < lists.size(); i++) {
            //未使用
            Integer highLevelIndex = lists.size() - i - 1;
            //获取单元数据
            String single = lists.get(i);
            //对单元数据进行翻译 。
            String nextResult = getNumberFromFChinese(single);
            //lists中每位都是4位数截取 ，所以这里需要乘以10000进行叠加
            Long next = Long.valueOf(Integer.valueOf(result) * (int)(Math.pow(10, 4)) + Integer.valueOf(nextResult));
            result = next.toString();
        }
        //将开头0抹掉
        result = result.replaceFirst("^(0+)", "");
        return result;
    }

    /**
     * 通过中文数字获取4位数阿拉伯数字
     * 万以内的数据转换
     * @param single
     * @return
     */
    private String getNumberFromFChinese(String single) {
        String result = "0";
        Integer highIndex = 1;
        for (int i = 0; i < single.length(); i++) {
            String str = String.valueOf(single.charAt(i));
            int unit = ChineseNumber.level.indexOf(str);
            int number = ChineseNumber.number.indexOf(str);
            if (unit == -1) {
                //当前数字是万以内的单位即  千百十其中之一
                int next = 0;
                if (i < single.length() - 1) {
                    //如果不是最后一位，则需要考虑当前位的权重
                    next = ChineseNumber.level.indexOf(String.valueOf(single.charAt(i + 1)));
                }
                result=String.valueOf(Integer.valueOf(result)+number * (int) (Math.pow(10, next)));
            }
        }
        //权重叠加
        result = ""+Integer.valueOf(result) * (int) (Math.pow(10, highIndex - 1));
        return result;
    }

    /**
     * 阿拉伯数字转中文数字
     * 12354 --> 一万两千三百五十四
     * @param alabo 阿拉伯数字
     * @return 中文数字
     */
    public String getNumberFromAlabo(String alabo) {
        String result = "";
        List<String> list = new ArrayList<>();
        for (int length = alabo.length()-1; length >= 0; length--) {
            list.add(String.valueOf(alabo.charAt(length)));
        }
        List<List<String>> lists = CollectionUtil.averageSize(list, 4);
        Collections.reverse(lists);
        if (CollectionUtil.isNotEmpty(lists)) {
            for (int index=0;index<lists.size();index++) {
                List<String> singleNumList = lists.get(index);
                //反转集合
                Collections.reverse(singleNumList);
                //默认0 false
                Boolean zeroflag =false;
                String chinese = "";
                for (int j=0 ; j<singleNumList.size();j++) {
                    Integer number = Integer.valueOf(singleNumList.get(j));
                    if (number == 0 && !zeroflag && afterNotAllZero(singleNumList, j)) {
                        //第一次遇到0 且后面有小单位内并不是全为0
                        chinese += ChineseNumber.number.get(number);
                        //修改遇零状态true
                        zeroflag = true;
                    } else if(number!=0) {
                        //映射出对应的中文数字
                        chinese += ChineseNumber.number.get(number) + ChineseNumber.level.get(singleNumList.size()-j-1);
                    }
                }
                if (index==lists.size()&&chinese.substring(0, 1).equals(ChineseNumber.number.get(0))) {
                    //条件永远不成立。
                    chinese = chinese.substring(1);
                }
                //并不是全部为0，该高级单位才会生效
                if (chinese.length()>0&&!ChineseNumber.highLevel.contains(chinese.substring(chinese.length() - 1))) {
                    result += chinese + ChineseNumber.highLevel.get(lists.size() - 1 - index);
                }
            }
        }
        return result;
    }

    /**
     * 判断singleNumList在j位置之后是否全是0
     * @param singleNumList
     * @param j
     * @return
     */
    private boolean afterNotAllZero(List<String> singleNumList, int j) {
        for (int i = j+1; i < singleNumList.size(); i++) {
            if (!"0".equals(singleNumList.get(i))) {
                return true;
            }
        }
        return false;
    }

    public static void main(String[] args) {
        Integer right = 0;
        Integer total = 10000000;
        List<Map<String, Object>> list = new ArrayList<>();
        for (int i = 0; i < total; i++) {
            Integer number = MathUtil.getInstance().getRandom(1, 1000000000);
            //System.out.println(i);
            //Integer number = 400001989;
            String chinese = DigitUtil.getInstance().getNumberFromAlabo(number.toString());
            String alabo = DigitUtil.getInstance().getNumberFromChinese(chinese);
            boolean equals = alabo.equals(number.toString());
            if (equals) {
                right++;
            } else {
                Map<String, Object> map  = new HashMap<>();
                map.put("number", number);
                map.put("alabo", alabo);
                map.put("chinese", chinese);
                list.add(map);
            }
        }
        for (Map<String, Object> map : list) {
            System.out.println(map);
        }
        System.out.println("成功率："+Double.valueOf(right/(double)total));
    }
}



加入战队
# 加入战队