人民币大小写转换~~

最新推荐文章于 2020-06-05 21:56:31 发布

Castiel丶Luo

最新推荐文章于 2020-06-05 21:56:31 发布

阅读量838

点赞数

首先，数字应该分段，分成万以下的、万、亿、兆这几个段，并且每个段的长度固定是4个数字。比如说 123456 分为两个段，前面一个未满的段：12 ，后面是满的段：3456 。

其次，每个满段其实都是个十百千四个单位。比如：12345678 ，转成数字大写是：壹仟贰佰叁拾肆万伍仟陆佰柒拾捌，发现什么规律了吗？

最后，就是处理一些必须有 0 的问题了，比如说：303 ，不能说：叁佰叁，应该是：叁佰零叁，这个“零”有很多讲究的。

针对这些规律，我有针对性的整理出来两个方法：SingleConvert 、MultiConvert 。其中 SingleConvert 处理段内的逻辑，MultiConvert 处理段间的逻辑，在段内的数字 0 问题穿插到 SingleConvert 方法中，段间的数字 0 问题穿插到 MultiConvert 方法中。另外，小数部分的处理，只有两位数字，可以写死，这个最简单了。

说一下数字 0 的逻辑。

数字【3003】转换出来应该是【叁仟零叁】，数字【303】转换出来应该是【叁佰零叁】，可以看到段内连续出现一个或多个数字 0 的情况下，只会出现一个汉字【零】。

数字【3000000000300】转换出来应该是【叁兆零叁佰】，数字【300000300】转换出来应该是【叁亿零叁佰】，可以看到段间连续出现一个或多个数字 0 的情况下，只会出现一个汉字【零】。

所以，段内逻辑和段间逻辑，在连续出现多个【零】的时候，只保留一个【零】。

数字【300】转换出来应该是【叁佰】，数字【3000】转换出来应该是【叁仟】，可以看到在段内最后不管连续出现多少【零】，都抹掉不提。

所以，段内逻辑中，末尾的一个或多个【零】，均不保留。

还有两个不值得提的规律：每个数字对应一个单位，必定是【个十百千】；每段对应一个单位，从低到高的对应是【空、万、亿、兆、……】。

原谅我不知大更高的单位是什么了，这辈子没见过那么多钱，神那～～

然后，然后就没规律了，下面上代码：

using System;

using System.Collections.Generic;

using System.Diagnostics;

using System.Linq;

using System.Text;

namespace Lenic.Core

{

    /// <summary>

    /// 数字转大写汉字字符类

    /// </summary>

    [DebuggerStepThrough]

    public class NumericConvert

    {

        #region Private Fields

        /// <summary>

        /// 段的分隔字符，从低到高依次增加：空、万、亿、万亿，最高不超过万亿的数字都可以

        /// </summary>

        public static readonly string[] DefaultRangeNumeric = new string[] { string.Empty, "万", "亿", "兆" };

        /// <summary>

        /// 位的分隔字符，从低到高依次是：仟、佰、拾、空

        /// </summary>

        public static readonly char[] DefaultUnitNumeric = new char[] { '仟', '佰', '拾', char.MinValue };

        /// <summary>

        /// 数字替换的字符，从低到高依次是：零、壹、贰、叁、肆、伍、陆、柒、捌、玖

        /// </summary>

        public static readonly char[] DefaultCharNumeric = new char[] { '零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖' };

        private char[] charNumeric = DefaultCharNumeric;

        private string[] rangeNumeric = DefaultRangeNumeric;

        private char zeroNumeric = DefaultCharNumeric[0];

        private char[] unitNumeric = DefaultUnitNumeric;

        #endregion

        #region Business Methods

        /// <summary>

        /// 重置数字替换的字符，必须从小到大是 10 个汉字字符。

        /// </summary>

        /// <param name="data">目标字符数组</param>

        /// <returns>成功替换则返回 <c>true</c> 。</returns>

        public bool ResetCharNumeric(char[] data)

        {

            if (data == null || data.Length != 10)

                return false;

            charNumeric = data;

            zeroNumeric = data[0];

            return true;

        }

        /// <summary>

        /// 重置位的分隔字符，必须从小到大是 4 个汉字字符。

        /// </summary>

        /// <param name="data">目标字符数组</param>

        /// <returns>成功替换则返回 <c>true</c> 。</returns>

        public bool ResetUnitNumeric(char[] data)

        {

            if (data == null || data.Length != 4)

                return false;

            unitNumeric = data;

            return true;

        }

        /// <summary>

        /// 重置段的分隔字符。

        /// </summary>

        /// <param name="data">目标字符数组</param>

        public void ResetRangeNumeric(string[] data)

        {

            rangeNumeric = data ?? DefaultRangeNumeric;

        }

        /// <summary>

        /// 执行数字转大写汉字字符的操作。

        /// </summary>

        /// <param name="obj">待转换的数字</param>

        /// <returns>转换完成的大写汉字字符串。</returns>

        public string Convert(decimal obj)

        {

            if (obj > 9999999999999999.99M)

                throw new ApplicationException("The numeric too big!");

            var data = obj.ToString("#.##");

            var list = data.Split('.');

            var result = MultiConvert(list[0]);

            if (list.Length > 1)

                result += DecimalConvert(list[1]);

            return result;

        }

        #endregion

        #region Private Methods

        private string MultiConvert(string data)

        {

            var list = Split(data).ToArray();

            var results = new List<string>();

            foreach (var item in list)

                results.Add(SingleConvert(item));

            var sbResult = new StringBuilder();

            var len = results.Count;

            var index = len - 1;

            for (int i = 0;

            i < len;

            i++)

            {

                var item = results[i];

                if ((i + 2 < len) && item == zeroNumeric.ToString() && results[i + 1].StartsWith(zeroNumeric.ToString()))

                    continue;

                if (!(i == (len - 1) && item == zeroNumeric.ToString()))

                    sbResult.Append(item);

                var unit = rangeNumeric[index - i];

                if (unit != string.Empty && item != zeroNumeric.ToString())

                    sbResult.Append(unit);

            }

            if (sbResult[sbResult.Length - 1] == zeroNumeric)

                sbResult.Remove(sbResult.Length - 1, 1);

            sbResult.Append("元");

            return sbResult.ToString();

        }

        private string SingleConvert(string data)

        {

            var len = data.Length;

            var result = new List<char>();

            var previousChar = char.MinValue;

            var unitIndex = len == 4 ? 0 : (4 - len);

            for (int i = 0;

            i < len;

            i++)

            {

                var item = CharToInt(data[i]);

                var currentChineseChar = charNumeric[item];

                if (currentChineseChar == previousChar && previousChar == zeroNumeric && currentChineseChar == zeroNumeric)

                    continue;

                else

                {

                    result.Add(previousChar = currentChineseChar);

                    var currentUnit = unitNumeric[unitIndex + i];

                    if (currentChineseChar != zeroNumeric && currentUnit != char.MinValue)

                        result.Add(currentUnit);

                }

            }

            if (result.Count != 1 && result.Last() == zeroNumeric)

                result.RemoveAt(result.Count - 1);

            return new string(result.ToArray());

        }

        private string DecimalConvert(string data)

        {

            StringBuilder sbResult = new StringBuilder();

            if (data[0] != '0')

            {

                sbResult.Append(charNumeric[CharToInt(data[0])]);

                sbResult.Append("角");

            }

            if (data[1] != '0')

            {

                sbResult.Append(charNumeric[CharToInt(data[1])]);

                sbResult.Append("分");

            }

            return sbResult.ToString();

        }

        private IEnumerable<string> Split(string data)

        {

            var len = data.Length / 4;

            var mod = data.Length % 4;

            if (mod != 0)

                len += 1;

            var startIndex = 0;

            var blockLength = mod != 0 ? mod : 4;

            for (int i = 0;

            i < len;

            i++)

            {

                yield return data.Substring(startIndex, blockLength);

                startIndex += blockLength;

                blockLength = 4;

            }

        }

        private int CharToInt(char obj)

        {

            return ((int)obj) - 48;

        }

        #endregion

    }

}