汉字数字大小写转换

最新推荐文章于 2021-07-28 23:11:30 发布
最新推荐文章于 2021-07-28 23:11:30 发布
阅读量663 收藏
点赞数
分类专栏： java学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhuixunhebe1/article/details/20767221
版权
private static String[] CH = { "", "", "拾", "佰", "仟", "万", "", "", "", "亿", "", "", "", "兆" };
        private static String[] CHS_NUMBER = { "零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖" };

       
        public static String getCHSNumber(String money)
        {
            String chs = "";
            String tmp_int = money.Substring(0, money.IndexOf("."));
            String tmp_down = money.Substring(money.IndexOf(".")+1);
            char[] tmp_int_char = tmp_int.ToCharArray();
            String[] tmp_chs = new String[tmp_int_char.Length];
            int tab = 0;
            for (int i = 0; i < tmp_int_char.Length; i++)
            {
                tab = tmp_int_char.Length - i - 1;
                if (tmp_int_char.Length <= 5)
                {
                    tmp_chs[tab] = CHS_NUMBER[(int)float.Parse(tmp_int_char[i] + ".0")];
                    if (!tmp_chs[tab].Equals("零"))
                    {
                        // tmp_int_char.Length - i 为数字所在的位数 
                        chs = chs + tmp_chs[tab] + CH[tmp_int_char.Length - i];
                    }
                    else
                    {
                        // 当数字中有零时就在后加上零，如果超过１个以上的零也只加一个零 
                        if (!chs.EndsWith("零") && tab != 0)
                        {
                            chs = chs + tmp_chs[tab];
                        }
                        else if (chs.EndsWith("零") && tab == 0)
                        {
                            chs = chs.Substring(0, chs.Length - 1);
                        }
                    }
                }
                // 　如果数字的位数大于５和小于９时 
                if (tmp_int_char.Length > 5 && tmp_int_char.Length < 9)
                {
                    tmp_chs[tab] = CHS_NUMBER[(int)float.Parse(tmp_int_char[i] + ".0")];
                    // 如：123,1234分成两部分 
                    // 第１部分123：万以上亿以下 
                    if (tab >= 4)
                    {
                        // 当前数字不是大小零时 
                        if (!tmp_chs[tab].Equals("零"))
                        {
                            chs = chs + tmp_chs[tab] + CH[tab - 3];
                            // 　当第１部分算完时在加上"万" 
                            if (tab == 4)
                            {
                                chs = chs + "万";
                            }
                        }
                        else
                        {
                            // 当前数字为大小"零"时 
                            // 判断前一次形成在字符串结尾有没有零 
                            // 　如果没有零就加上零 
                            if (!chs.EndsWith("零"))
                            {
                                chs = chs + tmp_chs[tab];
                            }
                            // 当第１部分算完时
                            if (tab == 4)
                            {
                                // 　先判断字符串有没有零 
                                // 　如果有零时就把零去掉再加上"万" 
                                if (chs.EndsWith("零"))
                                {
                                    chs = chs.Substring(0, chs.Length - 1);
                                    chs = chs + "万";
                                }
                                else
                                {
                                    // 　如果没有零就直接加上"万" 
                                    chs = chs + "万";
                                }
                            }
                        }
                    }
                    // 如：123,1234分成两部分 
                    // 第１部分1234：万以下 
                    if (tab < 4)
                    {
                        if (!tmp_chs[tab].Equals("零"))
                        {
                            // tmp_int_char.Length - i 为数字所在的位数 
                            chs = chs + tmp_chs[tab] + CH[tmp_int_char.Length - i];
                        }
                        else
                        {
                            // 当数字中有零时就在后加上零，如果超过１个以上的零也只加一个零 
                            if (!chs.EndsWith("零") && tab != 0)
                            {
                                chs = chs + tmp_chs[tab];
                            }
                            if (chs.EndsWith("零") && tab == 0)
                            {
                                chs = chs.Substring(0, chs.Length - 1);
                            }
                        }
                    }
                }
                // 　如果数字的位数大于５和小于９时 
                if (tmp_int_char.Length >= 9 && tmp_int_char.Length <= 12)
                {
                    tmp_chs[tab] = CHS_NUMBER[(int)float.Parse(tmp_int_char[i] + ".0")];
                    if (tab >= 8 && tab < 12)
                    {
                        // 当前数字不是大小零时 
                        if (!tmp_chs[tab].Equals("零"))
                        {
                            chs = chs + tmp_chs[tab] + CH[tab - 7];
                            // 　当第１部分算完时在加上"万" 
                            if (tab == 8)
                            {
                                chs = chs + "亿";

                            }
                        }
                        else
                        {
                            // 当前数字为大小"零"时 
                            // 判断前一次形成在字符串结尾有没有零 
                            // 　如果没有零就加上零 
                            if (!chs.EndsWith("零"))
                            {
                                chs = chs + tmp_chs[tab];
                            }
                            // 当第１部分算完时 
                            if (tab == 8)
                            {
                                // 　先判断字符串有没有零 
                                // 　如果有零时就把零去掉再加上"万" 
                                if (chs.EndsWith("零"))
                                {
                                    chs = chs.Substring(0, chs.Length - 1);
                                    chs = chs + "亿";
                                }
                                else
                                {
                                    // 　如果没有零就直接加上"万" 
                                    chs = chs + "亿";
                                }
                            }
                        }
                    }
                    // 如：123,1234分成两部分 
                    // 第１部分123：万以上亿以下 
                    if (tab >= 4 && tab < 8)
                    {
                        // 当前数字不是大小零时 
                        if (!tmp_chs[tab].Equals("零"))
                        {
                            chs = chs + tmp_chs[tab] + CH[tab - 3];
                            // 　当第１部分算完时在加上"万" 
                            if (tab == 4)
                            {
                                chs = chs + "万";
                            }
                        }
                        else
                        {
                            // 当前数字为大小"零"时 
                            // 判断前一次形成在字符串结尾有没有零 
                            // 　如果没有零就加上零 
                            if (!chs.EndsWith("零"))
                            {
                                chs = chs + tmp_chs[tab];
                            }
                            // 当第１部分算完时 
                            if (tab == 4)
                            {
                                // 　先判断字符串有没有零 
                                // 　如果有零时就把零去掉再加上"万" 
                                if (chs.EndsWith("零"))
                                {
                                    chs = chs.Substring(0, chs.Length - 1);
                                    if (!chs.EndsWith("亿"))
                                        chs = chs + "万";
                                }
                                else
                                {
                                    // 　如果没有零就直接加上"万" 
                                    if (!chs.EndsWith("亿"))
                                        chs = chs + "万";
                                }
                            }
                        }
                    }
                    // 如：123,1234分成两部分 
                    // 第１部分1234：万以下 
                    if (tab < 4)
                    {
                        if (!tmp_chs[tab].Equals("零"))
                        {
                            // tmp_int_char.Length - i 为数字所在的位数 
                            chs = chs + tmp_chs[tab] + CH[tmp_int_char.Length - i];
                        }
                        else
                        {
                            // 当数字中有零时就在后加上零，如果超过１个以上的零也只加一个零 
                            if (!chs.EndsWith("零") && tab != 0)
                            {
                                chs = chs + tmp_chs[tab];
                            }
                            if (chs.EndsWith("零") && tab == 0)
                            {
                                chs = chs.Substring(0, chs.Length - 1);
                            }
                        }
                    }
                }
                // 　如果数字的位数大于12和小于16时 
                if (tmp_int_char.Length > 12 && tmp_int_char.Length <= 16)
                {
                    tmp_chs[tab] = CHS_NUMBER[(int)float.Parse(tmp_int_char[i] + ".0")];
                    if (tab >= 12 && tab < 16)
                    {
                        // 当前数字不是大小零时 
                        if (!tmp_chs[tab].Equals("零"))
                        {
                            chs = chs + tmp_chs[tab] + CH[tab - 11];
                            // 　当第１部分算完时在加上"万" 
                            if (tab == 12)
                            {
                                chs = chs + "兆";
                            }
                        }
                        else
                        {
                            // 当前数字为大小"零"时 
                            // 判断前一次形成在字符串结尾有没有零 
                            // 　如果没有零就加上零 
                            if (!chs.EndsWith("零"))
                            {
                                chs = chs + tmp_chs[tab];
                            }
                            // 当第１部分算完时 
                            if (tab == 12)
                            {
                                // 　先判断字符串有没有零 
                                // 　如果有零时就把零去掉再加上"万" 
                                if (chs.EndsWith("零"))
                                {
                                    chs = chs.Substring(0, chs.Length - 1);
                                    chs = chs + "兆";
                                }
                                else
                                {
                                    // 　如果没有零就直接加上"万" 
                                    chs = chs + "兆";
                                }
                            }
                        }
                    }
                    if (tab >= 8 && tab < 12)
                    {
                        // 当前数字不是大小零时 
                        if (!tmp_chs[tab].Equals("零"))
                        {
                            chs = chs + tmp_chs[tab] + CH[tab - 7];
                            // 　当第１部分算完时在加上"万" 
                            if (tab == 8)
                            {
                                chs = chs + "亿";
                            }
                        }
                        else
                        {
                            // 当前数字为大小"零"时 
                            // 判断前一次形成在字符串结尾有没有零 
                            // 　如果没有零就加上零 
                            if (!chs.EndsWith("零"))
                            {
                                chs = chs + tmp_chs[tab];
                            }
                            // 当第１部分算完时 
                            if (tab == 8)
                            {
                                // 　先判断字符串有没有零 
                                // 　如果有零时就把零去掉再加上"万" 
                                if (chs.EndsWith("零"))
                                {
                                    chs = chs.Substring(0, chs.Length - 1);
                                    if (!chs.EndsWith("兆"))
                                        chs = chs + "亿";
                                }
                                else
                                {
                                    // 　如果没有零就直接加上"万" 
                                    if (!chs.EndsWith("兆"))
                                        chs = chs + "亿";
                                }
                            }
                        }
                    }
                    // 如：123,1234分成两部分 
                    // 第１部分123：万以上亿以下 
                    if (tab >= 4 && tab < 8)
                    {
                        // 当前数字不是大小零时 
                        if (!tmp_chs[tab].Equals("零"))
                        {
                            chs = chs + tmp_chs[tab] + CH[tab - 3];
                            // 　当第１部分算完时在加上"万" 
                            if (tab == 4)
                            {
                                chs = chs + "万";
                            }
                        }
                        else
                        {
                            // 当前数字为大小"零"时 
                            // 判断前一次形成在字符串结尾有没有零 
                            // 　如果没有零就加上零 
                            if (!chs.EndsWith("零"))
                            {
                                chs = chs + tmp_chs[tab];
                            }
                            // 当第１部分算完时 
                            if (tab == 4)
                            {
                                // 　先判断字符串有没有零 
                                // 　如果有零时就把零去掉再加上"万" 
                                if (chs.EndsWith("零"))
                                {
                                    chs = chs.Substring(0, chs.Length - 1);
                                    if (!chs.EndsWith("亿"))
                                        if (!chs.EndsWith("兆"))
                                            if (!chs.EndsWith("兆"))
                                                chs = chs + "万";
                                }
                                else
                                {
                                    // 　如果没有零就直接加上"万" 
                                    if (!chs.EndsWith("亿"))
                                        if (!chs.EndsWith("兆"))
                                            chs = chs + "万";
                                }
                            }

                        }
                    }
                    // 如：123,1234分成两部分 
                    // 第１部分1234：万以下 
                    if (tab < 4)
                    {
                        if (!tmp_chs[tab].Equals("零"))
                        {
                            // tmp_int_char.Length - i 为数字所在的位数 
                            chs = chs + tmp_chs[tab] + CH[tmp_int_char.Length - i];
                        }
                        else
                        {
                            // 当数字中有零时就在后加上零，如果超过１个以上的零也只加一个零 
                            if (!chs.EndsWith("零") && tab != 0)
                            {
                                chs = chs + tmp_chs[tab];
                            }

                            if (chs.EndsWith("零") && tab == 0)
                            {
                                chs = chs.Substring(0, chs.Length - 1);
                            }
                        }
                    }
                }
                // 　如果数字的位数大于16 
                if (tmp_int_char.Length > 16)
                {
                    tmp_chs[tab] = CHS_NUMBER[(int)float.Parse(tmp_int_char[i] + ".0")];
                    if (tab >= 12)
                    {
                        chs = chs + tmp_chs[tab];
                        // 　当第１部分算完时在加上"万" 
                        if (tab == 12)
                        {
                            chs = chs + "兆";
                        }
                    }
                    if (tab >= 8 && tab < 12)
                    {
                        // 当前数字不是大小零时 
                        if (!tmp_chs[tab].Equals("零"))
                        {
                            chs = chs + tmp_chs[tab] + CH[tab - 7];
                            // 　当第１部分算完时在加上"万" 
                            if (tab == 8)
                            {
                                chs = chs + "亿";
                            }
                        }
                        else
                        {
                            // 当前数字为大小"零"时 
                            // 判断前一次形成在字符串结尾有没有零 
                            // 　如果没有零就加上零 
                            if (!chs.EndsWith("零"))
                            {
                                chs = chs + tmp_chs[tab];
                            }
                            // 当第１部分算完时 
                            if (tab == 8)
                            {
                                // 　先判断字符串有没有零 
                                // 　如果有零时就把零去掉再加上"万" 
                                if (chs.EndsWith("零"))
                                {
                                    chs = chs.Substring(0, chs.Length - 1);
                                    if (!chs.EndsWith("兆"))
                                        chs = chs + "亿";
                                }
                                else
                                {
                                    // 　如果没有零就直接加上"万" 
                                    if (!chs.EndsWith("兆"))
                                        chs = chs + "亿";
                                }
                            }
                        }
                    }
                    // 如：123,1234分成两部分 
                    // 第１部分123：万以上亿以下 
                    if (tab >= 4 && tab < 8)
                    {
                        // 当前数字不是大小零时 
                        if (!tmp_chs[tab].Equals("零"))
                        {
                            chs = chs + tmp_chs[tab] + CH[tab - 3];
                            // 　当第１部分算完时在加上"万" 
                            if (tab == 4)
                            {
                                chs = chs + "万";
                            }
                        }
                        else
                        {
                            // 当前数字为大小"零"时 
                            // 判断前一次形成在字符串结尾有没有零 
                            // 　如果没有零就加上零 
                            if (!chs.EndsWith("零"))
                            {
                                chs = chs + tmp_chs[tab];
                            }

                            // 当第１部分算完时 
                            if (tab == 4)
                            {
                                // 　先判断字符串有没有零 
                                // 　如果有零时就把零去掉再加上"万" 
                                if (chs.EndsWith("零"))
                                {
                                    chs = chs.Substring(0, chs.Length - 1);
                                    if (!chs.EndsWith("兆"))
                                        if (!chs.EndsWith("亿"))
                                            chs = chs + "万";
                                }
                                else
                                {
                                    // 　如果没有零就直接加上"万" 
                                    if (!chs.EndsWith("兆"))
                                        if (!chs.EndsWith("亿"))
                                            chs = chs + "万";
                                }
                            }
                        }
                    }

                    // 如：123,1234分成两部分 
                    // 第１部分1234：万以下 
                    if (tab < 4)
                    {
                        if (!tmp_chs[tab].Equals("零"))
                        {
                            // tmp_int_char.Length - i 为数字所在的位数 
                            chs = chs + tmp_chs[tab] + CH[tmp_int_char.Length - i];
                        }
                        else
                        {// 当数字中有零时就在后加上零，如果超过１个以上的零也只加一个零 
                            if (!chs.EndsWith("零") && tab != 0)
                            {
                                chs = chs + tmp_chs[tab];
                            }
                            if (chs.EndsWith("零") && tab == 0)
                            {
                                chs = chs.Substring(0, chs.Length - 1);
                            }
                        }
                    }
                }
            }

            if (tmp_down != null)
            {
                char[] tmp = tmp_down.ToCharArray();
                if (tmp.Length == 1)
                {
                    if (tmp[0] != '0')
                        chs = chs + "元" + CHS_NUMBER[(int)float.Parse(tmp[0] + ".0")] + "角整";
                    else
                        chs = chs + "元整";
                }
                else
                {
                    if (tmp[1] != '0' && tmp[0] != '0')
                    {
                        chs = chs + "元" + CHS_NUMBER[(int)float.Parse(tmp[0] + ".0")] + "角"
                                    + CHS_NUMBER[(int)float.Parse(tmp[1] + ".0")] + "分";
                    }
                    else if (tmp[1] != '0' && tmp[0] == '0')
                    {
                        chs = chs + "元零" + CHS_NUMBER[(int)float.Parse(tmp[1] + ".0")] + "分";
                    }
                }
            }
            else
            {
                chs = chs + "元整";
            }
            return chs;
        }
侯卓
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
获取中文字符串中的数字并转换成阿拉伯数字
InE
12-13 5204
获取中文字符串中的数字并转换成阿拉伯数字<?phpfunction charN2intN($str) { $arr_char = array('1一壹','2二贰两','3三叁','4四肆','5五伍','6六陆','7七柒','8八捌','9九玖'); //计数单位 $arr_char_digit = array('0零','十拾','百佰','千仟','万','亿');
c# - 汉字数字，阿拉伯数字，相互转换
yuxuac的专栏
02-02 2354
using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace DesignPatterns.ChineseNumConvertor { public class Node { public string Unit { get; set...
《word-大小写转换》
武力戡乱的博客
07-28 1877
1、快捷键shift+f3。 2、第一按下：大写，第二次按下：小心。
阿拉伯数字转大写汉子
ZHFDBK的博客
08-27 942
1转一
中文数字转阿拉伯数字（最大不超过1万亿）
aoeace
04-09 318
  import java.util.HashMap; import java.util.Map; import java.util.regex.Matcher; import java.util.regex.Pattern; public class DigitUtil { private static Map&lt;String, Integer&gt; MAP_AL...
数字大小写转换.rar
05-05
标题中的“数字大小写转换.rar”就是一个针对这种需求的工具或资源，可能是包含了一个能够实现这种转换的软件或者模板。描述中提到的“方便于造价或合同填写总价用”，进一步明确了这个工具的主要应用场景，即在编制...
华为面试题数字大小写转换
09-04
"华为面试题数字大小写转换"就是一个典型的例子，它要求将一个四位数转化为对应的中文表示。这个题目主要涉及到数字与字符串之间的转换、数组操作、条件判断以及字符串连接等编程基本概念。 首先，我们来看给出的...
java实现人民币大小写转换方法分享
09-04
8. **最终结果**：整数部分的处理结果（prefix）和小数部分的处理结果（suffix）组合在一起，加上“整”字（代表无小数部分），就构成了完整的人民币大小写转换结果。 9. **代码注释**：代码中包含了丰富的注释，...
C# 数字大小写转换器 实例源码（系统操作
04-26
在C#编程中，开发一个数字大小写转换器是一个常见的需求，特别是在财务软件或报表生成器等场景下，为了方便人类阅读和机器处理，我们可能需要将数字转换为大写或小写的文字形式。本实例源码就是针对这一需求提供的一...
js工具处理之数字转大写格式
相约9.28,幸福那一刻
11-27 397
直接上码： input输入： 57) && event.keyCode!=46 || /\.\d\d$/.test(value))event.returnValue=false"/> 转换方法 function numToHanzi(n) { var fraction = ['角', '分']; var digit = ['零', '壹', '贰', '叁
java将中文数字替换为阿拉伯数字
jrymos软件工作室
07-22 5103
擦,今天在网上搜了好久,居然没有阿拉伯数字替换中文数字的算法, 后来好不容易找了一个,居然是错的,日了狗了. 搞了半天,最后还是自己动手写了一个.测试: import static org.junit.Assert.*;import org.junit.Test;public class S2Test { @Test public void testS2() { a
中文数字转阿拉伯数字
grllery的博客
04-21 1701
中文数字转阿拉伯数字
把中文表示的数字转成阿拉伯数字 - java
衣衫破旧 歌声温柔
04-16 4780
问题描述： 输入一个中文字符串，使用中文表示的数字形式。如一百，一千万，四千二百万零三十。 输出对应的数字，如100，1000000，42000030。思路： 遇到这个问题一开始觉得挺简单的，用一个字符串和一个数组对应下标就找到数字了，然后一步步累加。 后来发现不太简单，还要考虑如三百二十万这种情况，就是最后一位比前面的数位大，还要乘上去。 在csd
前端练习14 将数字转换为文字
多啦的博客
12-10 1683
题目 给出这样一组数字： '11100101' 1代表yes，0代表no,要寻求完成一个switchStr函数，最终的输出结果是: 1~3：”yes”,2~4:”no”,5:”yes”,6:”no”,7:”yes” 实现 首先想到用for循环遍历实现，要注意遍历时起始的下标： const switchStr = str = &gt; { let currentStr = str[0]; ...
python 转换数字为中文的大写
热门推荐
王福旭的专栏
12-02 1万+
python 转换数字为中文的大写 python 转换为中文的大写数字，比较简单，有需要的同学可以拿去使用，没做角和分 可以自己修改 下面为代码 #-*-coding:utf-8 -*- import logging import urllib2 # urllib2.request_host('https://www.g-banker.com/trade/bullion/buy?produc
Python 中文(大写)数字转阿拉伯数字
Just for fun的专栏
08-16 9919
中文转数字，小数的化考虑点字进一步封装即可。 # constants for chinese_to_arabic CN_NUM = { '〇' : 0, '一' : 1, '二' : 2, '三' : 3, '四' : 4, '五' : 5, '六' : 6, '七' : 7, '八' : 8, '九' : 9, '零' : 0, '壹' : 1, '贰' : 2, '叁' :...
js 数字金额大小写转换成中文大写
lychao89的专栏
08-12 9201
function Arabia_to_Chinese(Num) { for(i=Num.length-1;i>=0;i--) { Num = Num.replace(",","")//替换tomoney()中的“,” Num = Num.replace(" ","")//替换tomoney()中的空格 } Num = Num.replace("￥","")//替换掉可能出现的￥字符
阿拉伯数字转换为简写汉字 JS
yaoyyl的博客
01-17 2518
//阿拉伯数字转换为简写汉字 function ArabiSimplified(Num) { for (var i = Num.length - 1; i >= 0; i--) { Num = Num.replace(",", "")//替换Num中的“,” Num = Num.replace(" ", "")//替换Num中的空格 } if
java计算当前时间和对比的过期时间…
zhuixunhebe1的专栏
03-08 3428
public static int getLicenseTime() { try { String licensetime = com.chinawiserv.platform.SystemConfig.getOverTime(); if (licensetime == null || licensetime.equals("")) { return -1; } else if (licenset
python中有什么能转换汉字数字大小写的函数
最新发布
03-27
Python中可以使用第三方库`cn2an`和`chinese_num_util`来实现汉字数字和阿拉伯数字之间的转换，但是目前还没有官方提供的函数可以直接实现汉字数字大小写的转换。需要自行编写函数来实现。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值