精华内容
参与话题
问答
  • 中文数字转阿拉伯数字

    千次阅读 2019-04-21 11:37:50
    中文数字转阿拉伯数字

    中文数字转阿拉伯数字

    # -*- 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))
    
    展开全文
  • /// 阿拉伯数字转换成中文数字 /// /// /// public string NumToChinese(string x) { string[] pArrayNum = { “零”, “一”, “二”, “三”, “四”, “五”, “六”, “七”, “八”, “九” }; //为数字位数...
    /// <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 ... * 阿拉伯数字转中文数字 * <p>

    在使用 《 [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));
        }
    }
    
    
    

    加入战队

    # 加入战队

    展开全文
  • 数字转中文数字大写

    2015-07-24 11:12:02
    财务中文大写,阿拉伯数字转中文数字大写,数字转化大写汉字
  • java中文数字与阿拉伯数字相互转换

    千次阅读 2019-06-13 13:26:52
    最近有一个业务需要用到中文数字与阿拉伯数字相互转换,废话不多说直接上代码. 中文数字/阿拉伯数字互转第一次完善:https://blog.csdn.net/qq_26896085/article/details/100081049 package ...
  • 中文数字转为阿拉伯数字

    千次阅读 2016-11-15 11:06:38
    中文数字转为阿拉伯数字
  • Java中数字转中文数字

    千次阅读 2019-03-27 19:55:19
    在Java后台需要把阿拉伯数字转化未中文数字,比如“123”转化为“一百二十三” public static String int2chineseNum(int src) { final String num[] = {"零", "一", "二", "三", "四", "五", "六", "七", "八", ...
  • 阿拉伯数字与中文数字转换算法

    千次阅读 2017-03-20 01:21:29
    根据《算法的乐趣》简单总结一下:中文数字的特点中文数字直接“数字+权位”的方式组成数字,比如阿拉伯数字100,中文表示为一百,其中“一”为数字,“百”为权位。常用的数字权位有“十”,“百”,“千”,“万”...
  • python中文数字转换为阿拉伯数字 中文数字与阿拉伯数字转换 只能转数字,传参中包含非数字会错. def zhuanhuan(str): zhong={'零':0,'一':1,'二':2,'三':3,'四':4,'五':5,'六':6,'七':7,'八':8,'九':9}; danwei={'...
  • js 阿拉伯数字转化为中文数字

    千次阅读 2018-07-17 09:30:07
    当书写数字时,都不忘了使用中文式的数字,比如写单据,章节名时,写上中文数字显得高大上一些。在这里,就和大家分享一下,如何通过js进行阿拉伯数字与中文数字的转化。 代码奉上: function toChinesNum(num){...
  • php中文数字转化成阿拉伯数字

    千次阅读 2017-05-15 14:22:03
    中文数字转化成阿拉伯数字
  • 做一个项目,其中遇到一个问题,需要将数据中的中文数字转换成阿拉伯数字,比如将12345转换成字符串’一二三四五’,或者将字符串’aa五三二‘转换成’aa532‘,通过不断的摸索,解决问题的同时,将解决方法记录下来...
  • JS中阿拉伯数字转中文数字

    千次阅读 2018-08-28 17:22:21
    做学业评价项目的时候,后台返回的数字为阿拉伯数字,而页面上需要展示中文数字。 解决 // 阿拉伯数字转中文 private numberConvertToUppercase (num: number): string { const upperNumbers: string[] = ['...
  • Python 中文数字转阿拉伯数字

    千次阅读 2018-06-26 23:24:45
    # 思路:将数字拆为()亿()万(),分别计算()值并相加 danwei = {'九':9, '八':8, '七':7, '六':6, '五...# 计算中文数字值 def cal(inStr): import re sum = 0 if len(inStr) == 0: # 处理空字段,如:一...
  • * 将阿拉伯数字转换为中文数字 */ + (NSString *)translationArabicNum:(NSInteger)arabicNum { NSString *arabicNumStr = [NSString stringWithFormat:@"%ld",(long)arabicNum]; NSArray *arabicNumeralsArray ...
  • 工作中经常遇到阿拉伯数字转换称为中文数字或者大写金额,在网上搜了下,cn2an口碑较好,遂进行了一番学习。 安装 pip install cn2an 依赖库为setuptools、PyYAML 查看版本 In [1]: import cn2an In [2]: cn2an.__...
  • 中文数字文字转换成阿拉伯数字

    千次阅读 2019-10-08 11:55:48
    在参考率网络上的部分代码后,写了一个简单的转换方法,原本是想用在抓取电子书中的标题使用的,比如,... 2 /// 将中文数字转换为阿拉伯数字(逐字符分析的方式) 3 /// </summary> 4 /// <param name...
  • 正则匹配中文数字

    万次阅读 2018-03-30 15:51:38
    正则匹配中文数字 运营导入小说时遇到小麻烦,想要在章节目录前面加一些符号,word等工具搜半天没搜到,就想着用正则匹配试一下, 于是用notepad++试了一下,正则匹配中文数字章节。 表达式为:(第[\u4e00-\u9fa...
  • PostgreSQL阿拉伯数字转简体中文数字 源代码 CREATE OR REPLACE FUNCTION udf_digits2hanzi(num bigint) RETURNS text LANGUAGE plpgsql AS $function$ DECLARE --节权 unitPos INTEGER := 1; allChinese ...
  • java将阿拉伯数字转换为中文数字

    千次阅读 2017-03-15 15:35:48
    java将阿拉伯数字转换为中文数字
  • 阿拉伯数字与中文数字的相互转换

    千次阅读 2017-08-15 23:28:50
    中文数字是 “数字+权位”的方式组成数字,比如百,千,万。 中文数字每个数字后都会跟上一个权位,权位就是数字的量值,相当于阿拉伯数字的数位 中文计数以万为小节,万以下没有节权,万以上是亿为节权。 中文...
  • //从含 中文数字 特殊字符字符串中 取出 中文数字 String str = "^2^3da4AA2b3中文sae34科e技b2报2`~!@#$%^&*()_+-=[]{};':\",. str = str.replaceAll("[^0-9\\u4e00-\\u9fa5]", ""); System.out.println(str); ...
  • js中,把数字“123”转“一百二十三”,这种阿拉伯数字转中文数字 在网上看到有一种转换方案,使用起来比较容易,特记录一下 参考博客: https://blog.csdn.net/qq_34731574/article/details/71194273 var Utils={...
  • 阿拉伯数字转中文数字 // 节内转换算法 function SectionToChinese(section){ var strIns = '', chnStr = ''; var unitPos = 0; var zero = true; while(section > 0){ var v = section % 10; if(v === 0){ if(!...
  • JavaScript实现阿拉伯数字和中文数字互相转换阿拉伯数字转中文数字中文数字的特点: 每个计数数字都跟着一个权位,权位有:十、百、千、万、亿。 以“万”为小节,对应一个节权位,万以下没有节权位。 每个小节内部...
  • re匹配中文数字

    千次阅读 2019-01-22 17:45:49
    正则匹配中文数字 import re # 零 一 二 三 四 五 六 七 八 九 十 百 千 万 &amp;gt;&amp;gt;&amp;gt; reg = '[\u96f6\u4e00\u4e8c\u4e09\u56db\u4e94\u516d\u4e03\u516b\u4e5d \u5341\u767e \u...
  • Python中判断一个中文是否中文数字的方法

    千次阅读 多人点赞 2019-06-29 21:56:14
    Python内置功能非常强大,在字符串内置函数中提供了一个判断字符串是否全数字的方法,而且这个方法不只是简单判断阿拉伯数字,包括中文数字和全角的阿拉伯数字都认识,这个函数就是字符串的isnumeric方法。...
  • 最近在作东西的时候,需要使用中文数字与阿拉伯数字进行互相转换.在网搜了一下效果并不是十分理想.没有办法只好自己动手. 现在拿出来与大家分享,并不断完善. 需要注意的一些地方: 1.目前最大上限是...

空空如也

1 2 3 4 5 ... 20
收藏数 20,842
精华内容 8,336
关键字:

中文数字