大写金额转换器，支持 IFormatProvider 接口

[Q_282898034]

　　经常有人问这个问题，也经常有人回答，但大都不带注释，这使代码难以阅读，也不容易发现BUG，大家就等于在初级阶段做了很多重复劳动，所以我希望开发一个代码易读易懂的，供大家讨论并逐渐改进，做成比较成熟的转换器。所以写了个用正则表达式处理转换的，但没想到还是写了 7 条正则才完成，拼效率绝对拼不过循环和递归的，还请递归高人给补个方法。另外支持了　IFormatProvider 接口，使用起来比较方便，更方便日后逐渐扩充格式。

　　大家帮我测试这段代码，找到 BUG ，提供建议，添加方法，完善格式都有分，不够再加。大家需要的时候来这个帖子拷代码直接用行了。

using System;
using System.Text.RegularExpressions;


class 转换器 : IFormatProvider, ICustomFormatter
{
    public static readonly 转换器 大写金额 = new 转换器();
    private 转换器()
    { }
    object IFormatProvider.GetFormat(Type formatType)
    {
        return (this as ICustomFormatter);
    }
    string ICustomFormatter.Format(string format, object arg, IFormatProvider formatProvider)
    {
        bool isSelected = (format.Trim() == "大写");
        decimal number = 0M;
        try
        { number = Convert.ToDecimal(arg); }
        catch (Exception)
        { isSelected = false; }

        if (!isSelected)
            if (arg is IFormattable)
                return ((IFormattable)arg).
                    ToString(format, formatProvider);
            else
                return arg.ToString();


        // 格式化数字为两位小数的,带有位标志的数字,正数、负数和零分别对应分号隔开的格式
        string result = number.ToString("#穰'.'#仟#佰#拾#秭'.'#仟#佰#拾#垓'.'#仟#佰#拾#京'.'#仟#佰#拾#兆'.'#仟#佰#拾#億'.'#仟#佰#拾#萬'.'#仟#佰#拾#元.0角0分;负#穰'.'#仟#佰#拾#秭'.'#仟#佰#拾#垓'.'#仟#佰#拾#京'.'#仟#佰#拾#兆'.'#仟#佰#拾#億'.'#仟#佰#拾#萬'.'#仟#佰#拾#元.0角0分;零元");
        // 从字符串左侧开始替换子字符串，遇到汉字“零”或者阿拉伯数字 0 - 9，替换就结束。
        // 替换内容是捕获组 $1，该捕获组表示 0 个或 1 个在字符串最左侧的汉字“负”
        result = Regex.Replace(result, @"^(负?)[^零\d]*", "$1");
        // 替换字符串中以一个 0 开头，后跟一个字符，这种组合的连续。
        // 因为肯定不会出现两个阿拉伯数字连续的情况，所以后跟字符确定为汉字。
        // 规定该汉字不可以匹配汉字“元”。也不可以匹配右侧带“.”的汉字（特殊单位）。
        // 将所有找到的匹配替换为“0”，注意：结果可能会产生“0”的连续的情况。
        result = Regex.Replace(result, @"(0[^元](?!\.))+", "0");
        // 删除字符串最右侧的，或右侧带“.”的汉字左侧的，一个或多个“0”的连续。
        // 所有特殊单位的右侧带“.”，例如“億”“萬”“元”，这保证了上句不会替换它们。
        result = Regex.Replace(result, @"0+(\D\.|$)", "$1");
        // 替换所有以“.”开头的，一个汉字和一个“.”的组合，这是特殊单位左侧的个十百千位都是 0 造成的。
        // 所以删除该特殊单位的字符，左侧会有一个“0”和一个汉字的组合，该组合会包含被删掉的特殊单位的含义。
        result = Regex.Replace(result, @"(?<=\.)[^元]\.", "");
        // 删除掉所有“.”。
        result = Regex.Replace(result, @"\.", "");
        // 如果字符串最后以“元”结束，就换成“元整”。
        result = Regex.Replace(result, @"(元)$", "$1整");
        // 用匿名方法作代理，将每个数字替换成汉字形式。
        result = Regex.Replace(result, @"\d", delegate(Match m) { return "零壹贰叁肆伍陆柒捌玖"[m.Value[0] - '0'].ToString(); });

        return result;

    }
}
class Program
{
    static void Main(string[] args)
    {
        object[] data = { 0, 20050138000000M, "women", 0.425, 20.1, -9.63f };
        foreach (object o in data)
            Console.WriteLine("{0,30}  {1,-6}", o, string.Format(转换器.大写金额, "{0:大写}", o));
        Console.ReadKey();
    }
}

[ydlchina]

学习

[王集鹄]

　　　　　　牛　　　　　　　　　　　　　　　牛
　　　　　牛Ｂ牛　　　　　　　　　　　　　牛Ｂ牛
　　　　　牛Ｂ牛　　　　　　　　　　　　　牛Ｂ牛Ｂ
　　　　牛Ｂ牛Ｂ　　　　　　　　　　　　　Ｂ牛Ｂ牛Ｂ
　　　　牛Ｂ牛Ｂ牛　　　　　　　　　　　　Ｂ牛Ｂ牛Ｂ　　牛
　　　　Ｂ牛Ｂ牛Ｂ牛　　　　　　　　　　Ｂ牛Ｂ牛Ｂ牛　　Ｂ
　　　　　Ｂ牛Ｂ牛Ｂ牛　牛Ｂ　Ｂ牛Ｂ　Ｂ牛Ｂ牛Ｂ牛　　　　Ｂ
　　　　　　牛Ｂ牛Ｂ牛Ｂ　　牛　　　牛Ｂ牛Ｂ牛Ｂ　　　　　Ｂ
　　　　牛Ｂ牛Ｂ牛Ｂ牛　　　牛　　　　Ｂ牛Ｂ牛Ｂ牛　　　　　牛Ｂ
　　牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛　　　牛　　　　Ｂ牛Ｂ牛Ｂ牛Ｂ　　　　　Ｂ
牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛　　　牛　　　　Ｂ牛Ｂ牛Ｂ牛Ｂ牛　　　　Ｂ
　Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛　牛Ｂ　　牛Ｂ　Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛　　Ｂ
　　牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛　牛Ｂ　　牛Ｂ　Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ　Ｂ
　　　　牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛
　　　　　牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ
　　　　牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛
　　　牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛
　　Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛
　牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛
Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛
Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛
Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛
Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ
　Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛　牛Ｂ牛　　　牛Ｂ牛Ｂ
　　牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ　　　　　　　　牛Ｂ牛Ｂ
　　　　　　牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ　　　Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛
　　　　　　　牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ　Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ
　　　　　　　　　　牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛Ｂ牛　　Ｂ牛Ｂ牛Ｂ牛Ｂ牛
　　　　　　　　　　　　　　　牛Ｂ牛Ｂ牛Ｂ　　　Ｂ牛Ｂ牛Ｂ牛
　　　　　　　　　　　　　　　牛Ｂ牛Ｂ牛Ｂ　　　Ｂ牛Ｂ牛Ｂ牛
　　　　　　　　　　　　　　　牛　　Ｂ　Ｂ　　　Ｂ　Ｂ　　牛
　　　　　　　　　　　　　　　牛Ｂ牛Ｂ牛Ｂ　　　Ｂ牛Ｂ牛Ｂ牛

[fckadxz]

不合你谈这些鸡毛蒜皮的事了.做软件客户满意,代码健壮易读,少些维护,这些想必是共同的.你要的比较结果也出来了,这次是和前面 一位朋友 提到的,微软的那个 库 一起做的效率比较.欢迎大家拍砖.哈哈.http://topic.csdn.net/u/20080125/16/e525de9d-e92f-44b9-8a8c-ea86a08f084b.html?seed=498778585

[zrf2006]

很好很强大！！
我找了好久的贴子！！

[Q_282898034]

　　本来不想写循环递归的程序，因为我觉得微软的程序已经很好了，所以从另一个方向寻找最精简的代码，终于让我在 31 楼实现了 3 句代码完成几十行代码的壮举。可非常可爱的小猪非要拿速度来比，还号称比微软快，我看不惯他那段垃圾代码，只好把微软大神请出来了。这段程序是在反编译微软的架构上精简出来的，以 decimal 为基础，破解了原版人为的最大金额限制，可以运算到 decimal 的极限。运算不到 decimal 这个数量级别的别嚷嚷着和这段程序比速度，我随便写段32位小数字类型转换的就快过你，特别是看不懂 MSDN 还说自己的程序超越了微软的源码的。
　　下面附有测试结果。

using System;
using System.Collections.Generic;

static class RMB
{
    private static readonly string DigitText = "零壹贰叁肆伍陆柒捌玖";
    private static readonly string PositionText = "圆拾佰仟萬億兆京垓秭穰";
    private static readonly string OtherText = "分角整负";

    private static void GetFractionStack(int num, Stack<char> stack)
    {
        int fen, jiao = Math.DivRem(num, 10, out fen);
        if (fen != 0)
        {
            stack.Push(OtherText[0]);
            stack.Push(DigitText[fen]);
        }
        if (jiao != 0)
        {
            stack.Push(OtherText[1]);
            stack.Push(DigitText[jiao]);
        }
    }
    private static void GetIntegerStack(decimal num, int position, Stack<char> stack)
    {
        if (num < 10000M)
        {
            int _num = Decimal.ToInt32(num);
            for (int i = 0, mod_10 = 0; i < 4; i++)
            {
                bool behindZero = mod_10 == 0;
                _num = Math.DivRem(_num, 10, out mod_10);
                if (mod_10 == 0)
                {
                    if (behindZero)
                        if (_num == 0)
                            break;
                        else
                            continue;
                }
                else if (i > 0)
                    stack.Push(PositionText[i]);
                stack.Push(DigitText[mod_10]);
            }
        }
        else
        {
            GetIntegerStack(Decimal.Remainder(num, 10000M), position, stack);

            int mask = -1, offset = 4;
            while ((position & (0x1 << ++mask)) == 0) ;
            mask += offset;
            while (stack.Peek() == PositionText[offset++])
                stack.Pop();
            stack.Push(PositionText[mask]);

            GetIntegerStack(Decimal.Divide(num, 10000M), position + 1, stack);
        }
    }
    public static string DecimalFormatter(Decimal input)
    {
        Stack<char> stack = new Stack<char>(60);
        
        bool isNegate = input < Decimal.Zero;
        input = Decimal.Add(isNegate  ? Decimal.Negate(input) : input, 0.005M);
        decimal integer = Decimal.Truncate(input);
        int fraction = Decimal.ToInt32(Decimal.Multiply(Decimal.Subtract(input, integer), 100M));
        if (fraction == 0)
            stack.Push(OtherText[2]);
        else
            GetFractionStack(fraction, stack);
        if (integer != Decimal.Zero)
        {
            stack.Push(PositionText[0]);
            GetIntegerStack(integer, 1, stack);
            if (stack.Peek() == DigitText[0])
                stack.Pop();
        }
        else if (fraction == 0)
        {
            stack.Push(PositionText[0]);
            stack.Push(DigitText[0]);
        }
        if (isNegate)
            stack.Push(OtherText[3]);
        return new string(stack.ToArray());
    }
}
class Program
{
    static void Main()
    {
        decimal input = decimal.MaxValue;
        Console.WriteLine(input /= 1000M);
        // 国内银行通用上法转换:万万为亿,亿亿为兆
        Console.WriteLine(RMB.DecimalFormatter(input));
        Console.ReadKey();
    }
}

测试结果：

79228162514264337593543950335
柒萬玖仟贰佰贰拾捌億壹仟陆佰贰拾伍萬壹仟肆佰贰拾陆兆肆仟叁佰叁拾柒萬伍仟玖佰叁拾伍億肆仟叁佰玖拾伍萬零叁佰叁拾伍圆整

-79228162514264337593543950335
负柒萬玖仟贰佰贰拾捌億壹仟陆佰贰拾伍萬壹仟肆佰贰拾陆兆肆仟叁佰叁拾柒萬伍仟玖佰叁拾伍億肆仟叁佰玖拾伍萬零叁佰叁拾伍圆整

7.922816251426433759354395034
柒圆玖角贰分

（国内银行通用上法转换:万万为亿,亿亿为兆，只要对代码稍微修改，就可以实现中法，微软的设计架构确实下功夫了）
10000000000000000000000000000
壹萬億兆圆整
1000000000000000000000000000
壹仟億兆圆整
100000000000000000000000000
壹佰億兆圆整
10000000000000000000000000
壹拾億兆圆整
1000000000000000000000000
壹億兆圆整
100000000000000000000000
壹仟萬兆圆整
10000000000000000000000
壹佰萬兆圆整
1000000000000000000000
壹拾萬兆圆整
100000000000000000000
壹萬兆圆整
10000000000000000000
壹仟兆圆整
1000000000000000000
壹佰兆圆整
100000000000000000
壹拾兆圆整
10000000000000000
壹兆圆整
1000000000000000
壹仟萬億圆整
100000000000000
壹佰萬億圆整
10000000000000
壹拾萬億圆整
1000000000000
壹萬億圆整
100000000000
壹仟億圆整
10000000000
壹佰億圆整
1000000000
壹拾億圆整
100000000
壹億圆整
10000000
壹仟萬圆整
1000000
壹佰萬圆整
100000
壹拾萬圆整
10000
壹萬圆整
1000
壹仟圆整
100
壹佰圆整
10
壹拾圆整
1
壹圆整
0.1
壹角
0.01
壹分
0.001
零圆整
0 　　　（处理零）
零圆整
0.005　（四舍五入）
壹分
9.994
玖圆玖角玖分
9.995　（跨小数点四舍五入，一般自编程序经常在这出错）
壹拾圆整

[Q_282898034]

http://topic.csdn.net/u/20080125/16/e525de9d-e92f-44b9-8a8c-ea86a08f084b.html?seed=529739525
发表于：2008-01-28 06:10:3035楼 得分:0 
这个代码的字符串操作借鉴了   空间IV   的,但是整体算法完全不同.又把效率提高了一大截. 

你这不是也在“借鉴”。
　　下面这段就是我说的微软的源码，和我的代码差别非常大吧。我也只是“借鉴”了递归架构，其他代码都是我自己写出来的，所以我说是我写的，就好像你总是吸收了别人好的想法写出来的代码说是你的代码。不信你可以把下面这段代码和我 53楼 写的代码比较一下，假如你能看得懂的话。
　　你说返回值要转成字符串比较才公平，谁说的？我还觉得大家都返回 Stack 集合或字符数组测试速度才公平。
　　微软的程序向来层次分明。核心算法返回数组或集合形式的，界面层算法才转用户需要的字符串，这样便于日后程序的功能扩充和维护，例如用户可能需要“整”，可能不需要。这就可以在界面层操作而非核心层。
　　如果是你，一定在核心算法里增加 if 语句，把核心算法搞成补丁铺。像你那种不分层的浑然一体的结构，最后只能落得个全身补丁的下场。我倒是想把你的返回值改成比较优势的数组形式，可惜那样你得程序就变得更慢了。
　　另外返回字符集合而非字符串给界面层的好处是显而易见的，操作字符串带来的系统消耗比操作数组大的多，你可能理解不了，不过你改了我的返回值为字符串后速度明显下降，应该能明白这种消耗吧。
　　假如微软雇佣我们俩单独完成整个 EastAsiaNumericFormatter ，你的程序不分层，肯定满是补丁，维护困难。如果分层，在各层间用字符串传递，效率受很大影响，最终只能落后于我。况且我写的就是转字符串也快过你的，更别提你难以解决的跨小数点四舍五入错误和致命的万亿以上的单位错误。
　　还有 Console 可以直接输出 Char[]，为了照顾你得阅读习惯，我才转成 string 形式，其实根本没这必要。

以下反编译自微软代码：

protected virtual void GetIntegralStack(decimal num, ulong position, StackWithIndex stack)
{
    if (num < 10000M)
    {
        if ((num != 0M) || (position == 0xe8d4a51000L))
        {
            stack.Push(this.GetPositionText(position));
        }
        for (int i = 0; i < 4; i++)
        {
            int digit = (int) decimal.op_Modulus(num, 10M);
            ulong num4 = (ulong) Math.Pow(10.0, (double) i);
            num /= 10M;
            stack.Push(this.GetDigitText(digit, num4));
        }
    }
    else
    {
        this.GetIntegralStack(Math.Truncate(decimal.op_Modulus(num, 10000M)), position, stack);
        this.GetIntegralStack(Math.Truncate((decimal) (num / 10000M)), position * ((ulong) 0x2710L), stack);
    }
}

[Q_282898034]

感谢各位的参与，感谢猪哥对我程序的关注，没有他的激励和参与，我也不可能完成 31 楼和 53 楼这两段程序。

[fckadxz]

我为编程狂:你写的测试程序在作弊哟!你把 new string(s3.ToArray()) 这个放在时间测试区代码外,每次循环计时,都被躲掉了,所以,你测试的结果微软的快很多. 实际上并不是这样.也就是4:5的样子.

还有,反编译别人的代码算好大本事,值得你这样兴奋,还居然在我的帖子了说是你写的,哎.

我那个贴子还是给了你90分,看在你辛苦的份上. 不想跟你计较那么多了.

[fckadxz]

我又写了个 精度无限制,运行速度也还可以的版本,欢迎拍砖!
http://topic.csdn.net/u/20080125/16/e525de9d-e92f-44b9-8a8c-ea86a08f084b.html?seed=1677933837
关于四舍五入:Math.Round也是可以用的.

[shinaterry]

呵呵...

再位真可爱...

不如你们再比比RMB大写转小写的...

看看谁的程序更快...

^o^

[fckadxz]

//我觉得可以的

class Program
{
    static   void   Main(string[]   args) 
    { 
        Console.WriteLine(Math.Round(1.2, MidpointRounding.AwayFromZero));
        Console.WriteLine(Math.Round(1.5, MidpointRounding.AwayFromZero));
        Console.WriteLine(Math.Round(2.4, MidpointRounding.AwayFromZero));
        Console.WriteLine(Math.Round(2.5, MidpointRounding.AwayFromZero)); 
    } 
}

[fckadxz]

"兆" 有多大

侯捷注：2003/10/27 我在珠海与 hanlei 聊到，
大陆惯称的 "兆" 有多大？这是不是一个错误的用法？
hanlei 事後给了我这一封信。


--------------------------------------------------------------------------------

侯老师，您好

您提到"兆"这个单位，当时我一时迷糊，也没想清楚。回来後仔细考虑了一下，换算方法是1MB（兆）=1024KB。也就是说，一个"兆"等於1024个"千"，即百万。下面是一篇讨论这个问题的文章，从文中可以看出，1.44Mb这样的词里面的"兆"，是用了三法之中的"下法"，即以10递进。在一个台湾网站（http://www.math.tku.edu.tw/mathhall/mathinfo/lwymath/numberBOT.htm）中，也提到"自然科学中的兆指百万，例如：无线电频率一兆周期就是每秒震动一百万次"。在现实生活中有许多这样的单位，如兆赫(MHz）等等。
致礼

hanlei
2003-10-30


附：叁考文章
中国报导社出版的《世界语课本》第十二课"一兆是多少"中，明确地说一兆是 milion-oble miliono=biliono（一百万个百万，即10的12次方）。要数完这一兆，假如按每分钟数200，每小时就是12000，每天288000，每年就是105120000（一亿零五百一十二万），数完一兆，需九千五百多年 这需多少代人接力数数 这个一兆就是一万个亿。它是中国13亿人口数的769倍多。但是，在我们平日工作中也常碰到"兆"。如无线电中就有表频率的"兆赫芝"，表电阻的"兆欧"，压力有"兆帕"，等等。然而现代科技所称的这个"兆"绝不是"万亿"，而是"百万"，亦即miliono,（即106。）它是万亿的的百万分之一，换言之，两个"兆"相差一百万倍 假如按上述办法数数，後一个兆则只要约三天半的时间即可数完!

这究竟谁对呢？其实都是对的。这是怎麽回事？因为它们源自中国古代不同的计数体系。中国古代亿以上的大数计数方法有三个体系：这是我国东汉时期的《数述记遗》书中所载。

一是上法，为自乘系统: 万万为亿，亿亿为兆，兆兆为京。这种系统，希腊的阿基米德也采用过；10^4=万, 10^8=亿,10^16=兆,10^32=京

二是中法，为万进系统，皆以万递进：万 亿 兆 京 垓 秭 穰 沟(土旁) 涧 正 载┅┅(万万为亿 万亿为兆 万兆为京┅┅) ；10^4=万, 10^8=亿,10^12=兆,10^16=京

三是下法，为十进系统，皆以十递进： 万 亿 兆 京 垓 秭┅┅到了近代，直至解放前我国还流行十进的系统，即个 十 百 千 万 亿 兆 京 垓 秭 穰 沟(土旁) 涧 正 载 报，皆以十进，10万为亿，10亿为兆，10兆为京......；10^4=万, 10^5=亿,10^6=兆,10^7=京

现代的科学技术上用的"兆"属於第三法，就是 10^6，即百万。如：兆周(MHz) 兆欧(MΩ) 兆瓦(Mw)┅┅；而现代的"亿"却属於第二种即中法（与第一法的"亿"也相符）。13亿等於13乘10的8次方而并非10的5次方。

在一般情况下，为避免混淆，"兆"仅用于10^6，10^12则用"万亿"表达。再大的数字则用"百万亿" "千万亿" "亿亿" "十亿亿" "亿亿亿"┅

-- the end

[fckadxz]

我当初就是参照了这里的"一般情况".普通人,有几个知道 京 垓 秭 穰 沟(土旁) 涧 正 载?

[Q_282898034]

不必了，我承认他的快，假入银行不想有什么损失的话，是不会选择他那段代码的，宁可浪费几毫秒也会用我 53 楼的程序。

[huaer1011]

收藏

[GhostAdai]

这个一定要顶一下！

[fangxq57]

偶尔路过，也来凑个热闹。
二位本已属高手，切磋技艺何必脸红脖子粗，让我等看官们无所适从。
下面的代码是JAVA的，属于逐位一次转换，请楼主指教。

/* 人民币大小写转换
* 可处理小于一亿亿亿元的金额（24位整数、2位小数）
* [e-mail]
*/
public class RMBtoCHINESE { // 负数、四舍五入等参数规范问题不在这里处理
String sNum= "零壹贰叁肆伍陆柒捌玖负";
String sUni= "整分角元拾佰仟万拾佰仟亿拾佰仟万拾佰仟亿拾佰仟万拾佰仟";
private String R2C(String n0){ //参数必须为字符串如“100203000.45”
int L=n0.length();
if (L>27) return "数值溢出"; //包括小数点和2位小数
StringBuffer sN= new StringBuffer(); //转换前的字符串
sN.append(n0);
sN.deleteCharAt(L-3); //去除小数点
--L;
StringBuffer sT= new StringBuffer(); //转换后的字符串
if(sN.charAt(L-1) =='0')
sT.insert(0,'整'); //分位为零则尾部加'整'
boolean Ziro=false, a=false, b=false;
int n=0;
for(int i=1; i<=L; i=i+1) {
n= sN.charAt(L-i)-'0'; //数值
if(i==7 || i==15)
b= n==0; //万位、万亿位是零
if((i>7)&(i<11)||(i>15)&(i<19))
b=(n==0)& b; //万-亿位、或亿-亿位之间全是零
a=(i==1||i==3||i==7||i==11||i==15||i==19||i==23); //万亿、亿、万、元、分位为0时不写'零'
if( n>0 || (i>1 & a )){
if((i==11||i==19)& b)
sT.setCharAt(0, '亿'); //用'亿'覆盖'万'
else
sT.insert(0, sUni.charAt(i)); //插入单位
}
if( !(n==0 & (Ziro||a) ))
sT.insert(0, sNum.charAt(n)); //插入数值
Ziro= n==0;
}
if(n==0) sT.insert(0, '零');
return sT.toString();
}

[luweihuaihuai]

我也写了一个.用delphi写的.
给很多会计朋友用起来也挺好的
www.zhantool.com/daxie

[fangxq57]

[Quote=引用 66 楼 luweihuaihuai 的回复:]
我也写了一个.用delphi写的.
给很多会计朋友用起来也挺好的
www.zhantool.com/daxie
[/Quote]
下载试用了下，有点小错哎：100001001.01 > 壹亿万零壹仟零壹圆零壹分?
100000000000.00 > 壹仟亿零万圆?
...

[wuyi8808]

这个正则也很牛：

using System;
using System.Text.RegularExpressions;

class Program
{
  // 把阿拉伯数字的金额转换为中文大写数字
  static string ConvertToChinese(double x)
  {
    string s = x.ToString("#L#E#D#C#K#E#D#C#J#E#D#C#I#E#D#C#H#E#D#C#G#E#D#C#F#E#D#C#.0B0A");
    string d = Regex.Replace(s, @"((?<=-|^)[^1-9]*)|((?'z'0)[0A-E]*((?=[1-9])|(?'-z'(?=[F-L\.]|$))))|((?'b'[F-L])(?'z'0)[0A-L]*((?=[1-9])|(?'-z'(?=[\.]|$))))", "${b}${z}");
    return Regex.Replace(d, ".", delegate(Match m) { return "负元空零壹贰叁肆伍陆柒捌玖空空空空空空空分角拾佰仟萬億兆京垓秭穰"[m.Value[0] - '-'].ToString(); });
  }

  static void Main()
  {
    Random r = new Random();
    for (int i = 0; i < 10; i++)
    {
      double x = r.Next() / 100.0;
      Console.WriteLine("{0,14:N2}: {1}", x, ConvertToChinese(x));
    }
  }
}
/* 可能的输出：
  5,607,400.68: 伍佰陆拾萬柒仟肆佰元陆角捌分
  2,017,723.33: 贰佰零壹萬柒仟柒佰贰拾叁元叁角叁分
    751,181.17: 柒拾伍萬壹仟壹佰捌拾壹元壹角柒分
  7,849,851.53: 柒佰捌拾肆萬玖仟捌佰伍拾壹元伍角叁分
  2,629,143.90: 贰佰陆拾贰萬玖仟壹佰肆拾叁元玖角
 13,461,629.68: 壹仟叁佰肆拾陆萬壹仟陆佰贰拾玖元陆角捌分
  4,594,391.16: 肆佰伍拾玖萬肆仟叁佰玖拾壹元壹角陆分
 13,046,560.60: 壹仟叁佰零肆萬陆仟伍佰陆拾元陆角
 13,041,371.21: 壹仟叁佰零肆萬壹仟叁佰柒拾壹元贰角壹分
 20,639,609.44: 贰仟零陆拾叁萬玖仟陆佰零玖元肆角肆分
*/