用最基础的最简单Java知识做的一个小程序：将小写数字转换成大写数字。因为所学知识有限，只会接收键盘输入int类型，且刚学到了流程控制，所以程序不够优化，而且输入的数据只能是int类型，
其它类型运行的话就会报错，这是我目前知识比较局限所致这也是我目前所能做到的最好的了，不足之处还望大家多多指教。。。

1. /*
   
2. 需求：构造一个类，可以将10000以内的数字转换为大写数字
   
3. 
   
4.                 如：100=壹佰        107=壹佰零柒        168=壹佰陸十捌        35=叁拾伍        7=柒        130=壹佰叁十
   
5.                         1030=壹仟零叁拾
   
6. 
   
7. 因为所学知识有限，只会接收键盘输入int类型，且刚学到了流程控制，所以程序不够优化，而且输入的数据只能是int类型，
   
8. 其它类型就会报错，这是我目前知识比较局限所致这也是我目前所能做到的最好的了，不足之处还望大家多多指教。。。
   
9. 
   
10. */
    
11. 
    
12. import java.util.Scanner;
    
13. class zhuanhuan
    
14. {
    
15.         public static void main(String[] args)
    
16.         {
    
17.                 int jishu =0;
    
18.                 Scanner sc = new Scanner(System.in);//接收键盘输入
    
19.         while (true)//循环执行，方便使用
    
20.         {
    
21.                
    
22.                 System.out.println("请输入你想要转换的数字：");
    
23.                 int num =sc.nextInt();
    
24.                 int ge =0;
    
25.                 int shi =0;
    
26.                 int bai =0;
    
27.                 int qian =0;
    
28.                 if (num>=0&&num<=9)//拆分，将接收的数字分别为一位，两位，三位的情况下的各个位上的数字拆开
    
29.                 {
    
30.                         ge =num;
    
31.                 }
    
32.                 else if (num>=10&&num<=99)
    
33.                 {
    
34.                         ge =num%10;
    
35.                         shi =num/10%10;
    
36.                 }
    
37.                 else if (num>=100&&num<=999)
    
38.                 {
    
39.                         ge =num%10;
    
40.                         shi =num/10%10;
    
41.                         bai =num/100;
    
42.                 }
    
43.                 else if (num>=1000&&num<=9999)
    
44.                 {
    
45.                         ge =num%10;
    
46.                         shi =num/10%10;
    
47.                         bai =num/100%10;
    
48.                         qian =num/1000%10;
    
49.                 }
    
50.                 else System.out.println("输入数据不正确！！");//判断，如果输入数据不在范围内，则执行此句！
    
51. 
    
52.                         if (qian>0)//判断四位数，如果千位上数大于0，则调用一次jieguo，百位，十位，个位雷同
    
53.                         {
    
54.                                 jieguo(qian);
    
55.                                 System.out.print("仟");
    
56.                                 if (!(bai==0))
    
57.                                 {
    
58.                                         jieguo(bai);
    
59.                                         System.out.print("佰");
    
60.                                 }
    
61.                                 if ((bai==0)&!(shi==0))//如果百位为0，十位上不为零，则输出一个”零“
    
62.                                 {
    
63.                                         System.out.print("零");
    
64.                                 }
    
65.                                 if (!(shi==0))
    
66.                                 {
    
67.                                         jieguo(shi);
    
68.                                 }
    
69.                                 if ((shi==0)&!(ge==0))//如果十位为0，个位上不为零，则输出一个”零“
    
70.                                 {
    
71.                                         System.out.print("零");
    
72.                                 }
    
73.                        
    
74.                                 if (!(shi==0))
    
75.                                 {
    
76.                                         System.out.print("拾");
    
77.                                 }
    
78.                                 if (!(ge==0))
    
79.                                 {
    
80.                                         jieguo(ge);
    
81.                                 }
    
82.                         }
    
83.                         else if (bai>0)//判断三位数
    
84.                         {
    
85.                                 jieguo(bai);
    
86.                                 System.out.print("佰");
    
87.                                 if (!(shi==0))
    
88.                                 {
    
89.                                         jieguo(shi);
    
90.                                 }
    
91.                                 if ((shi==0)&!(ge==0))
    
92.                                 {
    
93.                                         System.out.print("零");
    
94.                                 }
    
95.                        
    
96.                                 if (!(shi==0))
    
97.                                 {
    
98.                                         System.out.print("拾");
    
99.                                 }
    
100.                                 if (!(ge==0))
     
101.                                 {
     
102.                                         jieguo(ge);
     
103.                                 }
     
104.                         }
     
105.                         else if (shi>0)//判断两位数
     
106.                         {
     
107.                                 jieguo(shi);
     
108.                                 System.out.print("拾");
     
109.                                 if (!(ge==0))
     
110.                                 {
     
111.                                         jieguo(ge);
     
112.                                 }
     
113.                         }
     
114.                         else if (ge>0)//判断一位数
     
115.                         {
     
116.                                 jieguo(ge);
     
117.                         }
     
118.                 System.out.println();
     
119.         }
     
120.         }
     
121.         public static void jieguo(int R)//把switch判断封装成一个方法jieguo
     
122.         {
     
123.                 int S=R;
     
124.                 switch (R)
     
125.                         {
     
126.                         case 1:
     
127.                                 System.out.print("壹");
     
128.                                 break;
     
129.                         case 2:
     
130.                                 System.out.print("貳");
     
131.                                 break;
     
132.                         case 3:
     
133.                                 System.out.print("叁");
     
134.                                 break;
     
135.                         case 4:
     
136.                                 System.out.print("肆");
     
137.                                 break;
     
138.                         case 5:
     
139.                                 System.out.print("伍");
     
140.                                 break;
     
141.                         case 6:
     
142.                                 System.out.print("陸");
     
143.                                 break;
     
144.                         case 7:
     
145.                                 System.out.print("柒");
     
146.                                 break;
     
147.                         case 8:
     
148.                                 System.out.print("捌");
     
149.                                 break;
     
150.                         case 9:
     
151.                                 System.out.print("玖");
     
152.                                 break;
     
153.                         }
     
154.         }
     
155. }
     

复制代码

不错不错，收藏了。

沙发是我自己的~~~

加油！！！

余翔 发表于 2014-5-20 22:38
不错不错，收藏了。

抢我沙发......{:2_31:}

我也写了下代码，像转换类的，用一个字符串数组是很省事的做法，超过超过10w的数，想了想，觉得有点麻烦，就没写了

1. 
   
2. import java.util.Scanner;
   
3. 
   
4. public class ToChineseForm {
   
5.         private static String[] num = {"零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"};
   
6.         private static String[] unit = {"", "拾", "佰", "仟", "万"};
   
7.        
   
8.         /**
   
9.          * 将输入的整数转换成中文大写形式，本方法接收int型入参
   
10.          * @param input
    
11.          * @return
    
12.          */
    
13.         public static String toChineseForm(int input){       
    
14.                 //将待转换的数值转换成字符串
    
15.                 String n = new String(new Integer(input).toString());               
    
16.                 return toChineseForm(n);
    
17.         }
    
18.        
    
19.         /**
    
20.          * 将输入的整数转换成中文大写形式，本方法接收String型入参
    
21.          * @param n
    
22.          * @return
    
23.          */
    
24.         public static String toChineseForm(String n){
    
25.                 //如果是0元，这直接返回“零元”               
    
26.                 if(n.equals("0")){
    
27.                         return "零元";
    
28.                 }
    
29.                
    
30.                 String ret = new String();
    
31.                
    
32.                 //只能转换100000以内的数
    
33.                 int nLength = n.length() - 1;
    
34.                 if(nLength > 4){
    
35.                         return "Input is too big";
    
36.                 }
    
37.                
    
38.                 //转换
    
39.                 for(int i = 0; i <= nLength; i++){
    
40.                         //获得各个位上的数值
    
41.                         int spotNum = (int)n.charAt(i)-48;
    
42.                         //如果存在非数字字符，则返回错误
    
43.                         if(spotNum < 0 || spotNum > 9){
    
44.                                 return "Input error";
    
45.                         }
    
46.                         //数值的大写字符加上位的大写字符（如1023为“壹仟零佰贰拾叁”，为了使之符合规则，还需要对“零进行调整”）
    
47.                         ret += num[spotNum] +  unit[nLength - i];                               
    
48.                 }
    
49.                        
    
50.                 //对字符串中的0进行调整
    
51.                 boolean f = true;
    
52.                 char[] rret = ret.toCharArray();
    
53.                 int tag = 0;
    
54.                 for(int i = rret.length - 1; i >= 0; i = i - 2){                       
    
55.                         if(rret[i] != '零'){
    
56.                                 //如果是第一次执行这段代码，那么f就是true，那么开始的零全都取消，如100为“壹佰零拾零”转换为“壹佰”
    
57.                                 if(f){
    
58.                                         f = false;
    
59.                                         continue;
    
60.                                 }
    
61.                                 //如果并非是第一次也就是中间有多个零，那么保留一个零
    
62.                                 if(rret[tag] == '0'){
    
63.                                         rret[tag + 1] = '零';
    
64.                                 }
    
65.                         }else{       
    
66.                                 //先把值为“零”的位及它的单位全部标志成0，如“壹佰零拾零”变成了“壹佰000”
    
67.                                 rret[i] = '0';       
    
68.                                 if(i < rret.length - 2){//第一个零没有后一位
    
69.                                         rret[i + 1] = '0';
    
70.                                 }
    
71.                                 //记录当前为'零'的位置
    
72.                                 tag = i;
    
73.                         }
    
74.                 }
    
75.        
    
76.                 //获得最后的结果，去掉字符数组中的0值
    
77.                 ret = "";
    
78.                 for(int i = 0; i < rret.length; i++){
    
79.                         if(rret[i] != '0'){
    
80.                                 ret += rret[i];
    
81.                         }
    
82.                 }
    
83.                
    
84.                 //返回前加上币值单位
    
85.                 return ret + "元";
    
86.         }
    
87. 
    
88.         public static void main(String[] args) {       
    
89.                 Scanner sc = new Scanner(System.in);
    
90.                 System.out.println("Input num:");
    
91.                 System.out.println(toChineseForm(sc.next()));               
    
92.                 sc.close();
    
93.                
    
94.         }
    
95. 
    
96. }

复制代码

屈_zi 发表于 2014-5-21 09:20
我也写了下代码，像转换类的，用一个字符串数组是很省事的做法，超过超过10w的数，想了想，觉得有点麻烦， ...

受教了{:3_57:}比我的简洁高效多了！！

加油加油。。。

加油加油。。。