通用数字中文互转换工具代码

今天在CodeProject首次发表文章：http://www.codeproject.com/KB/cs/NumberToFromWord.aspx，这里特别对中文数字转换做一说明。这里好像不能上传，欢迎大家到我的博客下载代码http://www.cnblogs.com/cruisoring/archive/2011/11/21/2257091.html
 
作为一个可扩展的工具，它能够实现数字转中文，以及中文转数字。大体思路是为每个数字建立建立字典
Dictionary<int, List<string>> NumberNameDict，即
 
            new Dictionary<int, List<string>>
            {
                {10, new List<string>{"十","拾"}},
                {20, new List<string>{"廿"}},
                {30, new List<string>{"卅"}},
                {100, new List<string>{"百", "佰"}},
                {1000, new List<string>{"千", "仟"}},
                {10000, new List<string>{"万"}},
                {100000000, new List<string>{"亿"}}
            },
            new List<string>() { "○一二三四五六七八九", "０１２３４５６７８９", "零壹贰叁肆伍陆柒捌玖" } 
 
存储所有对应的中文，其中List<string>仅对中文有效，存储0-9对应的中文字符，其中第一个字符串为缺省输出格式。类的初始化程序由此建立反向查询的字典Dictionary<string, int> WordNameDict：
 
             foreach (KeyValuePair<int, List<string>> kvp in NumberNameDict)
            {
                foreach (string s in kvp.Value)
                {
                    WordNameDict.Add(s, kvp.Key);                    if (!AllWords.Contains(s))
                        AllWords.Add(s);
                }
            }
 
 
 另外对于进制数建立列表protected List<int> groupNums：
            groupNums = new List<int>();            int max = NumberNameDict.Keys.Max();
            for (int i = firstGroupNum; i <= max; i*= 10 )
            {
                if (NumberNameDict.ContainsKey(i))
                {
                    //GroupNameDict.Add(i, NumberNameDict[i][0]);
                    groupNums.Add(i);
                }
            }
            groupNums.Sort(); 
 结果是{100000000, 10000, 1000, 100, 10}，即"亿万千百十"对应的数字列表。 
数字转中文为实现数字转中文， 首先对于每个非零的字符进行转换，其位数按照groupNums解析:
            List<string> sections = new List<string>();
            int remained = number;            for (int i = 0; i < groupNums.Count; i ++ )
            {
                if (remained < groupNums[i])
                    continue;                int whole = remained / groupNums[i];
                sections.Add(toWords(whole));                if (ToPlural != null && whole != 1)
                    sections.Add(ToPlural(NumberNameDict[groupNums[i]][0]));
                else
                    sections.Add(NumberNameDict[groupNums[i]][0]);                remained -= whole * groupNums[i];                if (remained != 0 && NeedInsertAnd(number, remained))
                //if(remained != 0 && remained < 100)
                    sections.Add(AndWords[0]);
            }            if (remained != 0)
                sections.Add(toWords(remained)); 
 
最终结果对于中文就是简单地将以上分散的字符串连接起来：
            StringBuilder sb = new StringBuilder();            for (int i = 0; i < sections.Count-1; i++)
            {
                sb.Append(sections[i] + Space);
            }
            sb.Append(sections.Last());            return sb.ToString(); 
 
为实现个性化的字符输出，可以调用以下接口，对特定字符进行定义。 
         /// </summary>
        /// <param name="number">The number</param>
        /// <param name="samples">
        /// The characters shall be used to replace the default ones.
        /// <example>
        /// For example, 234002052 by default will be converted to "二亿三千四百万零二千零五十二",
        ///     but if the samples is set to "佰零壹贰叁肆拾", then the output will be "贰亿叁千肆佰万零贰千零五拾贰"
        ///     any characters appeared in the samples will replace the default ones, thus "贰" will replace any "二"s for digit of "2".
        /// </example>
        /// </param>
        /// <returns>The converted string in words.</returns>
        private string toWords(int number, string samples)
        {
            string result = ToWords(number);            foreach (char ch in samples)
            {
                if (allCharacters.Contains(ch) && WordNameDict.ContainsKey(ch.ToString()))
                {
                    int digit = WordNameDict[ch.ToString()];
                    if (digit > 9 && !groupNums.Contains(digit))
                        continue;                    string digitStr = NumberNameDict[digit][0];                    if (digitStr.Length != 1 || digitStr[0] == ch)
                        continue;                    result = result.Replace(digitStr[0], ch);
                }
            }            return result;
        }
 
中文转换为数字最大的挑战在于难以判断数字对应的位数，考虑到：
 
高位应当出现在低位之前；
如果高位出现在低位之后，意味着它们应通过相乘组合为一个更高位。
低位出现在高位之后，意味着对之前的数字做个确认。
因此我使用一个堆栈stack<int>实现数字的解析，相应代码如下。
 
        /// <summary>
        /// Function to get number from split words.
        /// </summary>
        /// <param name="sectors">Words for each digits of the number</param>
        /// <returns>The number</returns>
        protected int fromWords(string[] sectors)
        {
            int result = 0, current, lastGroup=1, temp, maxGroup=1;
            Stack<int> stack = new Stack<int>();            foreach (string s in sectors)
            {
                if (AllWords.Contains(s))
                {
                    if (AndWords.Contains(s))
                        continue;                    if (WordNameDict.ContainsKey(s))
                    {
                        current = WordNameDict[s];                        if (groupNums.Contains(current))
                        {
                            //The current group is higher than any existed group, thus the digits shall be increased: by Multiply!!!!
                            if(current>= maxGroup)
                            {
                                temp = stack.Pop();
                                while (stack.Count!= 0)
                                {
                                    temp += stack.Pop();
                                };
                                temp *= current;
                                stack.Push(temp);
                                maxGroup *= current;
                                lastGroup = 1;
                            }
                            //The current group is higher than the last group, thus shall be add
                            else if (current > lastGroup)
                            {
                                temp = 0;                                while(stack.Peek() < current)
                                {
                                    temp += stack.Pop();
                                };                                temp *= current;
                                stack.Push(temp);
                                lastGroup = current;
                            }
                            else
                            {
                                temp = stack.Pop();
                                temp *= current;
                                stack.Push(temp);
                                lastGroup = current;
                            }
                        }
                        else
                        {
                            stack.Push(current);
                        }
                    }
                }
                else
                    throw new Exception();            }            do
            {
                result += stack.Pop();
            } while (stack.Count != 0);            return result;
        }
To parse the string to get number, the tryParse() is recommended.    Collapse | Copy Code
        /// <summary>
        /// The main function to try to retrieve number from string of words.
        /// </summary>
        /// <param name="numberInWords">The original word string of number</param>
        /// <param name="result">The converted number if successful</param>
        /// <returns>TRUE if parse successfully.</returns>
        protected virtual bool tryParse(string numberInWords, out int result)
        {
            result = -1;            try
            {
                string words = IsCaseSensitive ? numberInWords.ToLower() : numberInWords;                string[] sectors = split(words);                var contained = from s in sectors
                                where AllWords.Contains(s)
                                select s;                result = fromWords(contained.ToArray());
                return true;
            }
            catch
            {
                return false;
            }
        }   
 
 最终对数字与中英文的转换结果如下：
5: 五  ==> 5
20: 廿  ==> 20
21: 二十一  ==> 21
99: 九十九  ==> 99
100: 一百  ==> 100
102: 一百零二  ==> 102
131: 一百三十一  ==> 131
356: 三百五十六  ==> 356
909: 九百零九  ==> 909
1000: 一千  ==> 1000
1021: 一千零二十一  ==> 1021
2037: 二千零三十七  ==> 2037
12345: 一万二千三百四十五  ==> 12345
31027: 三万一千零二十七  ==> 31027
40002: 四万零二  ==> 40002
90010: 九万零一十  ==> 90010
100232300: 一亿零二十三万二千三百  ==> 100232300
234002052: 二亿三千四百万零二千零五十二  ==> 234002052
5: five  ==> 5
20: twenty  ==> 20
21: twenty-one  ==> 21
99: ninety-nine  ==> 99
100: one hundred  ==> 100
102: one hundred and two  ==> 102
131: one hundred and thirty-one  ==> 131
356: three hundreds and fifty-six  ==> 356
100232300: one hundred millions two hundreds and thirty-two thousands three hundreds  ==> 100232300
234002052: two hundreds and thirty-four millions two thousands and fifty-two  ==> 234002052
572030013: 五亿七千贰佰零叁万零壹拾叁  ==> 572030013
234002052: 贰亿叁千肆佰万零贰千零五拾贰  ==> 234002052
100232300: One Hundred Millions Two Hundreds And Thirty Two Thousands Three Hundreds  ==> 100232300
234002052: Two Hundreds And Thirty Four Millions Two Thousands And Fifty Two  ==> 234002052
第壹佰零八 张 = 108