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

分析：对于小数位，由于现在最小面值是分，所以只取两位小数。

对于整数位，比较难解决的是多个零连续出现时的表示方法，当多个零连续出现时，一般在中文中只显示一个零，

比如1001，就是“壹仟零壹元”，但如果这个0是处于关键位是（万、亿位），那么这个零的单位就不能省了，比如100000，就是“壹拾万元整”。

然后根将这两部分合理相加

下面是我的代码，（做了好几小时，惭愧:o）

1. public class ConvertCurrency {
   
2. 
   
3.         public static void main(String[] args) {
   
4.                 //因为最小单位就是分，所以暂时设定最小只能输入两个小数，整数不限
   
5.                 String str = "￥3540.01";
   
6.                 parse(str);
   
7.                 integrated();
   
8.         }
   
9.         
   
10.         public static void parse(String str) {
    
11.                 //定义一个正则表达式，作用：去掉整数位最前面的0，把整数位（第一组）和小数位（第3组）区别开来
    
12.                 Pattern p = Pattern.compile("￥{0,1}0*(\\d{1,})(\\.(\\d{1,2})){0,1}");
    
13.                 Matcher m = p.matcher(str);
    
14.                 if (p.matcher(str).matches()) {
    
15.                         while (m.find()) {
    
16.                                 String intPart = m.group(1);
    
17. //                                转换整数部分
    
18.                                 transInt(intPart);
    
19.                                 String decimalPart = m.group(3);
    
20. //                                转换小数部分
    
21.                                 transDec(decimalPart);
    
22.                         }
    
23.                 } else {
    
24.                         System.out.println("格式不对");
    
25.                         return;
    
26.                 }
    
27.         }
    
28.         
    
29.         //最后输出时，把整数部分和小数部分整合起来
    
30.         public static void integrated() {
    
31.                 if (intSB.length() == 0) {
    
32.                         if (decSB.length() == 0) {
    
33.                                 System.out.println("0元整");
    
34.                         } else {
    
35.                                 System.out.println(decSB);
    
36.                         }
    
37.                 } else {
    
38.                         if (decSB.length() == 0) {
    
39.                                 System.out.println(intSB + "整");
    
40.                         } else {
    
41.                                 System.out.print(intSB);
    
42.                                 System.out.println(decSB);
    
43.                         }
    
44.                 }
    
45.                
    
46.         }
    
47.         
    
48.         //这个用来放整数部分
    
49.         static StringBuilder intSB = new StringBuilder();
    
50.         public static void transInt(String intPart) {
    
51.                 long sum = Long.valueOf(intPart);        //之所以用Long,是因为int只有4个字节，最多支持21亿，Long的话，2的63次方，世界首富看了都傻眼
    
52.                 if (sum == 0) {
    
53.                         return;                //如果整数部分是0的话
    
54.                 } else {
    
55.                         intSB.insert(0, "元");
    
56.                 }
    
57.                
    
58.                 int pos = 0;        //记录当前处于整个数字中的第几位
    
59.                 boolean isZeroSequence = false;                //出现连续0的标志
    
60.                 while (sum != 0) {
    
61.                         pos++;                //当前位数
    
62.                         int temp = (int)(sum % 10);                //得到当前位是几
    
63.                         if (temp == 0) {
    
64.                                 addUnit(pos, true);                //先加上单位
    
65.                                 if (!isZeroSequence) {        //如果不是连续的出现0
    
66.                                         if (pos != 1) {                //如果不是个位的情况下，因为如果个位是0，可以直接跳过
    
67.                                                 String str = getChin(temp);
    
68.                                                 intSB.insert(0, str);
    
69.                                         }
    
70.                                         isZeroSequence = true;        //因为已经出现了一次0，所以先标记上
    
71.                                 }
    
72.                                 sum = sum / 10;                //去掉已经分析的一位
    
73.                         } else {
    
74.                                 isZeroSequence = false;  //既然这位不是0，那么把连续0的状态清除
    
75.                                 addUnit(pos, false);        //加上单位
    
76.                                 String str = getChin(temp);
    
77.                                 intSB.insert(0, str);
    
78.                                 sum = sum / 10;                //去掉已经分析的一位
    
79.                         }
    
80.                 }
    
81.                
    
82.         }
    
83.         
    
84.         public static void addUnit(int pos, boolean isZero) {
    
85.                 String unit;
    
86.                 if (!isZero || pos%4==1) {        //如果当前为不是0，或者当前位是0，但这个0处于万、亿位置上
    
87.                         if (pos <= 9) {                //小于9位数的情况下
    
88.                                 unit = getUnit(pos);
    
89.                                 intSB.insert(0, unit);
    
90.                         } else {                        //如果已经大于9位数
    
91.                                 int tempPos = pos - 8;
    
92.                                 while (tempPos > 8) {
    
93.                                         tempPos -= 8;
    
94.                                 }
    
95.                                 unit = getUnit(tempPos);
    
96.                                 intSB.insert(0, unit);
    
97.                         }
    
98.                 }
    
99.         }
    
100.         
     
101.         //这个用来放小数部分
     
102.         static StringBuilder decSB = new StringBuilder();
     
103.         public static void transDec(String decPart) {
     
104.                 if (decPart == null) {
     
105. //                        decSB.append("整");  //如果没有小数位，那就是整数
     
106.                         return;
     
107.                 }
     
108.                 int i = Integer.parseInt(decPart);
     
109.                 if (i == 0) {
     
110. //                        decSB.append("整");  //如果没有小数位，那就是整数
     
111.                         return;
     
112.                 }
     
113.                 if (decPart.length() == 1) {        //如果只有一位小数的话
     
114.                         decSB.append(getChin(i));
     
115.                         decSB.append(getUnit(-1));
     
116.                 } else if (decPart.length() == 2) {                //如果有两位小数的话
     
117.                         if (i<10) {                                                        //两位小数转化过来只有一位，那么肯定是角位必为0
     
118.                                 decSB.append(getChin(0));
     
119.                                 decSB.append(getChin(i));
     
120.                                 decSB.append(getUnit(-2));
     
121.                         } else {
     
122.                                 int jiao = i/10;
     
123.                                 decSB.append(getChin(jiao));
     
124.                                 decSB.append(getUnit(-1));
     
125.                                 int fen = i%10;
     
126.                                 if (fen == 0) return;
     
127.                                 decSB.append(getChin(fen));
     
128.                                 decSB.append(getUnit(-2));
     
129.                         }
     
130.                 }
     
131.         }
     
132.         
     
133.         
     
134.         
     
135. //        壹拾贰亿叁仟肆佰伍拾陆万柒仟捌佰玖拾元整零
     
136.         public static String getChin(int i) {
     
137.                 switch (i) {
     
138.                 case 0 : return "零";
     
139.                 case 1 : return "壹";
     
140.                 case 2 : return "贰";
     
141.                 case 3 : return "叁";
     
142.                 case 4 : return "肆";
     
143.                 case 5 : return "伍";
     
144.                 case 6 : return "陆";
     
145.                 case 7 : return "柒";
     
146.                 case 8 : return "捌";
     
147.                 case 9 : return "玖";
     
148.                 default :
     
149.                         return "error1";
     
150.                 }
     
151.         }
     
152. //        计算不大于9位数的单位
     
153.         public static String getUnit(int i) {
     
154.                 switch (i) {
     
155.                 case -2 : return "分";
     
156.                 case -1 : return "角";
     
157.                 case 1 : return "";                //如果小于9位数，这个可以输出“元”，但这样一来，对大于9位数的操作就比较麻烦了，所以把“元这个单位放到62行上”
     
158.                 case 2 : return "拾";
     
159.                 case 3 : return "佰";
     
160.                 case 4 : return "仟";
     
161.                 case 5 : return "万";
     
162.                 case 6 : return "拾";
     
163.                 case 7 : return "佰";
     
164.                 case 8 : return "仟";
     
165.                 case 9 : return "亿";
     
166.                 default :
     
167.                         return "error2";
     
168.                 }
     
169.         }
     
170. }

复制代码

不足之处，请指正，如有好的想法，欢迎交流，共同进步

需要这么复杂吗？反正我是懒得看:lol，代码太多，估计没几个人会看

这是第四步的笔试题？

努力了，支持一下

支持一下楼主

感觉好复杂

楼主赞！！！！！！！！！！！

你好，这是面试时候的笔试题还是被录取之后报道时候的笔试题目啊？

楼主的功力不错啊

GGdog 发表于 2014-5-27 11:52
你好，这是面试时候的笔试题还是被录取之后报道时候的笔试题目啊？

什么也不是，你看过张孝祥老师的面试宝典吗？
那里有一个“算法与编程”，这个就是最后一题，我习惯是先自己做，再看老师答案，但那个答案我有点失望，因为不符合现实中真正的转换规律

1. public class RenMingBi {
   
2. 
   
3.         /**
   
4.          * @param args add by zxx ,Nov 29, 2008
   
5.          */
   
6.         private static final char[] data = new char[]{
   
7.                         '零','壹','贰','叁','肆','伍','陆','柒','捌','玖'
   
8.                 };
   
9.         private static final char[] units = new char[]{
   
10.                 '元','拾','佰','仟','万','拾','佰','仟','亿'
    
11.         };
    
12.         public static void main(String[] args) {
    
13.                 // TODO Auto-generated method stub
    
14.                 System.out.println(
    
15.                                 convert(135689123));
    
16.         }
    
17. 
    
18.         public static String convert(int money)
    
19.         {
    
20.                 StringBuffer sbf = new StringBuffer();
    
21.                 int unit = 0;
    
22.                 while(money!=0)
    
23.                 {
    
24.                         sbf.insert(0,units[unit++]);
    
25.                         int number = money%10;
    
26.                         sbf.insert(0, data[number]);
    
27.                         money /= 10;
    
28.                 }
    
29. 
    
30.                 return sbf.toString();
    
31.         }
    
32. }

复制代码

贴给你看一下，或许你有新的想法

还没学到，不懂。

我基入学测试也遇到这个题了，代码稍微比这个少一点，思想也不难理解（搞了差不多一个下午吧）；分享了交流一下吧；
public class Test10 {
        /*
         * 10、 金额转换，阿拉伯数字转换成中国传统形式。 例如：101000001010 转换为 壹仟零壹拾亿零壹仟零壹拾圆整
         */                                                                                               
        public static void main(String[] args) {
                long value = 456789;//数值11111101000001010
                System.out.println(trans(value));
               
        }
        public static String trans(long value){
                if(String.valueOf(value).length()>17){//可以支持更大的位数只需要在unit数组中添加单位即可
                        return  "超出计算范围，请重新输入（小于17位为有限范围）。";
                }
                char[] chinses = new char[] { '零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌','玖' };
                //单位
                char[] unit = new char[] {' ', ' ', '拾', '佰', '仟','万'};
                // 接收到的数字转换成数字字符串
                StringBuilder sBuilderVal = new StringBuilder(String.valueOf(value));
                sBuilderVal = sBuilderVal.reverse();
                //存放返回结果
                StringBuilder reVal = new StringBuilder();
                int count = 1 ;
                //由于数值到亿的时候每次的单位变化就是在前一次单位加上亿的单位
                int num = 4 ;
                while(sBuilderVal!=null){
                        if(count>=4){
                                num++;
                        }
                        StringBuilder countVal = new StringBuilder();
                        StringBuilder tempVal = new StringBuilder();
                        if(sBuilderVal.length()<=num){
                                //如果串长度没有四位则取出所有字符
                                tempVal.append(sBuilderVal.substring(0, sBuilderVal.length()));
                                //表示已经取出所有字符，设置程序出口
                                sBuilderVal = null ;
                        }else{
                                //每次取出的位用于转换
                                tempVal.append(sBuilderVal.substring(0,num));
                                sBuilderVal = sBuilderVal.delete(0, num);
                        }
                        tempVal = tempVal.reverse();
                        int zeroCount = 0;
                        for(int i = 0 ; i<tempVal.length();i++){
                                int cVal = Integer.parseInt(String.valueOf(tempVal.charAt(i)));
                                //如果连续两个或两个以上的零则不添加到结果中
                                if(cVal==0 && zeroCount==0){
                                        countVal.append(chinses[cVal]);
                                        zeroCount++;
                                }else if(cVal!=0){
                                        //如果取出的数字不是连续的零则存储到结果中
                                        countVal.append(chinses[cVal]);
                                        countVal.append(unit[tempVal.length()-i]);
                                }
                        }
                        //设置单位
                        if(!countVal.toString().endsWith("零")){
                                switch(count){
                                case 1 :
                                        countVal.append("圆整");
                                        break ;
                                case 2 :
                                        countVal.append("万");
                                        break;
                                case 3 :
                                        countVal.append("亿");
                                        break ;
                                case 4 :
                                        countVal.append("兆");
                                        break;
                                }
                        }
                        count++;
                        reVal.insert(0, countVal);
                }
                return reVal.toString() ;
        }
}

楼主正解！

完全不懂.....不知道43期深圳能不能过啊

不觉明历，表示完全看不懂啊！！

我的笔试题也是这个，最后一道提，可是我没看正则表达式啊，，郁闷死了

楼主赞!

大神很厉害啊！赞一个

chang清 发表于 2014-6-10 13:00
我基入学测试也遇到这个题了，代码稍微比这个少一点，思想也不难理解（搞了差不多一个下午吧）；分享了交流 ...

谢谢你的分享，很厉害

这也太复杂了吧！用制表法那种方式，可以缩短很多代码！不过按照你的思路没有错！  不过用制表法的思维快多了！在开发中，就当作优化吧！！