1. public static void main(String[] args) {
   
2.                 System.out.println(changeToCN(101000001010D));
   
3. 
   
4.         }
   
5.         public static String changeToCN(double money){
   
6.                 //大写数字
   
7.                 String[] big = new String[]{"零","壹","贰","叁","肆","伍","陆","柒","捌","玖"};
   
8.                 //段位内的单位
   
9.                 String[] unit = new String[]{"","拾","佰","仟"};
   
10.                 //段位单位
    
11.                 String[] un = new String[]{"","萬","亿"};
    
12.                 //只取2位小数
    
13.                 String value = String.valueOf((long)(money*100));
    
14.                 //整数部分
    
15.                 String iValue = value.substring(0, value.length()-2);
    
16.                 //小数部分
    
17.                 String dValue = value.substring(value.length()-2);
    
18.                
    
19.                 //构造小数部分的大写数字
    
20.                 String dValueSb = "";
    
21.                 //如果两位小数都是0
    
22.                 if(dValue.equals("00")){
    
23.                         //添加“整”字
    
24.                         dValueSb +="整";
    
25.                 //如果小数点后1位是零
    
26.                 }else if(dValue.charAt(0)=='0'){
    
27.                         //添加格式为：零 "几" 分                 
    
28.                         dValueSb +=big[0]+big[dValue.charAt(1)-'0']+"分";
    
29.                 }else{
    
30.                         //如果小数点后2位都不是零，添加格式为："几"角 "几"分
    
31.                         dValueSb +=big[dValue.charAt(0)-'0']+"角"+big[dValue.charAt(1)-'0']+"分";
    
32.                 }
    
33.                
    
34.                 //构造整数部分的大写数字
    
35.                 String iValueSb = "";
    
36.                 //将整数部分拆散
    
37.                 char[] iChar = iValue.toCharArray();
    
38.                 // 标志当前位的上一位是否为有效0位（如万位的0对千位无效）
    
39.                 boolean preZero = false;
    
40.                 // 连续出现0的次数
    
41.                 byte zeroTimes = 0;
    
42.                 //对每位数进行操作
    
43.                 for(int i=0;i<iChar.length;i++){
    
44.                         //段位，4位数为一个段位，0段位表示万以下，1段位表示万，2段位表示亿
    
45.                         int dex = (iChar.length-i-1)/4;
    
46.                         //段位内的位置，0代表个，1代表十，2代表百，3代表千
    
47.                         int index = (iChar.length-i-1)%4;
    
48.                         //如果当前位置的数是0
    
49.                         if(iChar[i]=='0'){
    
50.                                 //记录前位是0
    
51.                                 preZero = true;
    
52.                                 //连续出现的0增加1
    
53.                                 zeroTimes++;
    
54.                                 //段位内个位数是0，只要段位内4位数不全是0，则添加段位单位：万、亿
    
55.                                 if(index==0&&zeroTimes<4){
    
56.                                         iValueSb +=un[dex];
    
57.                                         // 不管上一位是否为0，置为无效0位
    
58.                                         preZero = false;
    
59.                                 }
    
60.                                
    
61.                         }else{
    
62.                                 zeroTimes = 0;
    
63.                                 // 当出现不是零的数，首先查看上一位是否为有效0位
    
64.                                 if (preZero) {
    
65.                                         // 添加零，并且只会在此处添加一次零，不会出现重复零
    
66.                                         iValueSb += big[0];
    
67.                                         //复位
    
68.                                         preZero = false;
    
69.                                 }
    
70.                                 //添加该数字的大写
    
71.                                 iValueSb += big[iChar[i]-'0'];
    
72.                                 //如果是段位内的个位，添加段位单位：万、亿
    
73.                                 if(index==0){
    
74.                                         iValueSb +=un[dex];
    
75.                                 //如果不是，添加段位内单位：十、百、千
    
76.                                 }else{
    
77.                                         iValueSb += unit[index];
    
78.                                 }
    
79.                         }
    
80.                 }
    
81. 
    
82.                 // 如果整数部分存在,则有圆的字样
    
83.                 if (iValueSb.length() > 0)
    
84.                         iValueSb += '圆';
    
85.                
    
86.                 // 返回拼接起来的值
    
87.                 return iValueSb + dValueSb;
    
88.         }

复制代码

big[dValue.charAt(0)-'0']，请问这里边dValue.charAt(0)-'0'是什么意思

厉害啊。。。

菜鸟小白 发表于 2016-5-20 22:16
big[dValue.charAt(0)-'0']，请问这里边dValue.charAt(0)-'0'是什么意思

将字符转换成数字，char(At)得到的是字符不是int型数字所以要减去‘0的字符值’得到0

看了略长   之前也做了这道题      上网搜索了一下    感觉自己就是个弱智

1. public class Test9 {
   
2. 
   
3.         /**
   
4.          * 第九题: 金额转换，阿拉伯数字转换成中国传统形式。 例如：101000001010 转换为 壹仟零壹拾亿零壹仟零壹拾圆整
   
5.          *
   
6.          * @param args
   
7.          */
   
8.         public static void main(String[] args) {
   
9.                 //测试
   
10.                 System.out.println(converse(640_0000_0023L));
    
11.         }
    
12. 
    
13.         private static String converse(long num) {
    
14.                 //建立汉语数字数组
    
15.                 char[] chineseNum = { '零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖' };
    
16.                 //建立汉语量次数组
    
17.                 char[] unite = { '圆', '拾', '佰', '仟', '万', '拾', '佰', '仟', '亿', '拾', '佰',
    
18.                                 '仟' };
    
19.                 int index = 0;
    
20.                 long lastNum;
    
21.                 //从尾到头将数字按位置转换成汉语数字,并在后面加入量词.
    
22.                 StringBuffer sb = new StringBuffer();
    
23.                 while (num != 0) {
    
24.                         lastNum = num % 10;
    
25.                         sb.insert(0, unite[index++]);
    
26.                         sb.insert(0, chineseNum[(int) lastNum]);
    
27.                         num /= 10;
    
28.                 }
    
29.                 //使用正则表达式去重
    
30.                 return sb.toString().replaceAll("零[拾佰仟]", "零").replaceAll("零 *亿", "亿")
    
31.                                 .replaceAll("零{4}万", "零").replaceAll("零*万", "万")
    
32.                                 .replaceAll("零+圆", "圆").replaceAll("零+", "零")
    
33.                                 + "整";
    
34.         }
    
35. 
    
36. }
    

复制代码

父类使用方法的时候其实调用的是子类重写父类的方法