金额转换，阿拉伯数字的金额转换成中国传统的形式如：（￥1011）－>（一千零一拾一元整）输出，该怎么实现

1. public class Test10
   
2. {
   
3.    
   
4.         /**第10题：金额转换，阿拉伯数字转换成中国传统形式。 例如：101000001010   转换为   壹仟零壹拾亿零壹仟零壹拾圆整
   
5.          *
   
6.          * 分析：            1010 0000 1010
   
7.          *      壹仟零壹拾  亿     零  壹仟零壹拾 圆整
   
8.          *          1010     0101  1010
   
9.          *     壹仟零壹拾  亿 零壹佰零壹 万 壹仟零壹拾 圆整
   
10.          *            1111         1111        1111
    
11.          *     壹仟壹佰壹拾壹  亿 壹仟壹佰壹拾壹 万 壹仟壹佰壹拾壹 圆整
    
12.          *     
    
13.          *
    
14.          * 结论：通过分析找出一个规律：将一串数字从低位开始以4个数字为一组进行分组，
    
15.          *      每一组数字的位数是固定的第1位是个位，第2位是十位，第3位是百位，第4位是千位
    
16.          *      每一组的结尾处都有一个计数单位，比如 ****亿****万****圆
    
17.          *      
    
18.          *      假如数字的位置是i，我们可以通过i%4来获得该数字是个位还是百位、千位、万位
    
19.          *      如果i%4==0，那么在该数字后就要加上计数单位，再用i/4确定是加哪个计数单位
    
20.          *      i/4==0--------圆
    
21.          *      i/4==1--------万
    
22.          *      i/4==2--------亿
    
23.          *      
    
24.          *      将这一串数字转换为字符串后比较容易对每个数字处理。
    
25.          *      如何获得大写的数字？
    
26.          *      通过String类的charAt()方法获取字符，然后那该字符减去48（'0'的ASCII码是48），
    
27.          *      再通过查表法获得该数字的大写
    
28.          *      
    
29.          * 思路：
    
30.          * 1.将要转换的数字先转换为字符串，然后在将字符串反转（反转后数字的最高位在字符串的尾端，先从尾端开始判断）
    
31.          *
    
32.          * 2.定义一个StringBuilder类的对象cn，用于存放转换后的结果。
    
33.          *
    
34.          * 3.定义一个boolean类型的标识符flag，用于记录是否出现连续多个0
    
35.          *
    
36.          * 4.从尾端开始遍历字符串，取出第i位字符ch，判断ch-48是否等于0：
    
37.          *   如果等于0，如果flag为true，将'零'存进cn；flag为false则继续判断下一位
    
38.          *   如果不等于O，将数字的大写及位数存进cn，并将flag置为true。
    
39.          *   
    
40.          * 5.判断每一位之后要判断一下i%4是否等于0，如果等于0，就要存入相应的计数单位（圆、万、亿）
    
41.          *   在存入计数单位之前，应判断cn的最后一位是不是'零'，是'零'就要删去，避免出现"零圆"、"零万"、"零亿"
    
42.          *   
    
43.          * 6.特殊情况：如果万位至千万位之间都是0  则会出现****亿万****圆的情况，需要特殊处理，将'万'替换为'零'
    
44.          *
    
45.          * @param args
    
46.          */
    
47.         public static void main(String[] args)
    
48.         {
    
49.                 show(101000001010L);
    
50.                 show(103000000000L);
    
51.                 show(104000500000L);
    
52.                 show(106000700008L);
    
53.                 show(123456789876l);
    
54.                 show(9400015l);
    
55.                 show(1023l);
    
56.         }
    
57.         public static void show(long money)
    
58.         {
    
59.                 System.out.println(money + ":" + transToChinese(money));
    
60.         }
    
61.        
    
62.         //阿拉伯数字转换成中国传统形式
    
63.         public static String transToChinese(long money)
    
64.         {
    
65.                 //如果money等于0，直接返回零，如果大于一万亿，则抛异常
    
66.                 if(money == 0)
    
67.                         return "零";
    
68.                 if(money >= 1000000000000L)
    
69.                         throw new RuntimeException("钱太多处理不了");
    
70.                
    
71.                 //将数字转换为字符串，再将字符串转换为字符数组进行反转
    
72. //                String str = new Long(money).toString();
    
73.                 String str = String.valueOf(money);
    
74.                
    
75.                 char[] tempch = str.toCharArray();
    
76.                 for(int x = 0, y = tempch.length - 1; x < y; x++,y--)
    
77.                 {
    
78.                         char temp = ' ';
    
79.                         temp = tempch[x];
    
80.                         tempch[x] = tempch[y];
    
81.                         tempch[y] = temp;
    
82.                 }
    
83.                 str =  new String(tempch);
    
84.                
    
85.                 //用于查表法的数组
    
86.                 char[] capital = new char[]{'零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖'};
    
87.                 String[] place = new String[]{ "", "拾", "佰", "仟"};
    
88.                 String[] unit = new String[]{"圆整", "万", "亿"};
    
89.                
    
90.                 //cn用于存放转换为中文的结果，flag用于标识是否出现连续多个0
    
91.                 StringBuilder cn = new StringBuilder();
    
92.                 boolean flag = true;
    
93.                
    
94.                 //从尾端开始遍历字符串
    
95.                 for(int i = str.length() - 1; i >=0; i--)
    
96.                 {                       
    
97.                         int ch = str.charAt(i);
    
98.                        
    
99.                         //判断字符是否是'0'
    
100.                         if(ch-48 ==0)
     
101.                         {
     
102.                                 //第一次出现零，存入cn，将flag置为false
     
103.                                 if(flag)
     
104.                                 {
     
105.                                         cn.append(capital[0]);
     
106.                                         flag = false;
     
107.                                 }
     
108.                                 else
     
109.                                 {
     
110.                                         //连续多个零，后面的零就不在存入，继续判断下一个字符
     
111.                                         //在继续之前判断是否需要存入计数单位，并先判断计数单位前是不是有'零'，并将flag置为true
     
112.                                         if(i%4 ==0)
     
113.                                         {
     
114.                                                 if(cn.charAt(cn.length()-1) == '零')
     
115.                                                         cn.deleteCharAt(cn.length()-1);
     
116.                                                 cn.append(unit[i/4]);
     
117.                                                 flag = true;
     
118.                                         }
     
119.                                         continue;
     
120.                                 }
     
121.                                        
     
122.                         }
     
123.                         else  //字符不是'0'就存入cn，并存入其位数（个位、十位、百位、千位），并将flag置为true
     
124.                         {
     
125.                                 cn.append(capital[ch - 48]);
     
126.                                 cn.append(place[i%4]);
     
127.                                 flag = true;
     
128.                         }
     
129.                        
     
130.                         //每次循环都判断是否需要存入计数单位，并先判断计数单位前是不是有'零'，并将flag置为true
     
131.                         if(i%4 ==0)
     
132.                         {
     
133.                                 if(cn.charAt(cn.length()-1) == '零')
     
134.                                         cn.deleteCharAt(cn.length()-1);
     
135.                                 cn.append(unit[i/4]);
     
136.                                 flag = true;
     
137.                         }
     
138.                 }
     
139.                
     
140.                 //特殊情况：出现****亿万****圆的情况,将'万'替换为'零'
     
141.                 //        此举可能导致出现"零零"或者"零圆"，将多余的'零'删去
     
142.                 int index = 0;
     
143.                 if((index = cn.indexOf("亿万")) != -1)
     
144.                         cn.replace(index+1,index+2,"零");
     
145.                 if((index = cn.indexOf("零零")) != -1)
     
146.                         cn.deleteCharAt(index);
     
147.                 if((index = cn.indexOf("零圆")) != -1)
     
148.                         cn.deleteCharAt(index);
     
149.                
     
150.                 return cn.toString();
     
151.         }
     
152. }

复制代码

太给力了，