例如：输入：1002
         输出：壹仟零贰

中文转换非常简单，财务记账中常用到千位分隔计数法：从数字最右开始，每3位加一个逗号，比如1000000写成1,000,000。 这道题就用这个原理，从数字最右开始，每3位做一次转换

看不懂，努力中。。。

fantacyleo 发表于 2014-8-14 01:24
中文转换非常简单，财务记账中常用到千位分隔计数法：从数字最右开始，每3位加一个逗号，比如1000000写成1, ...

好吧，其实我一直不怎么明白这里，谢谢分享咯

1其实吧跟我们做的哪个基础差不多啊，就是把数字转化成大写数字，具体代码请参照


import java.io.*;
import java.lang.String;

public class change
{
public static void main(String agrs[])
{
  //Money用于存放输入的金额数
  long Money=0;
  String Mon[]={"零","壹","贰","叁","肆","伍","陆","柒","捌","玖"};
         
         String Mon1[]={"拾","佰","仟","万","拾万","百万","仟万","亿","拾亿","百亿","仟亿"},
         je[]=new String[30];//je[]数组用于存放数字金额被转换后的数字
         
         //n用于测试您是否有金额转换
         int n=agrs.length;
         
         if(n==0)
         System.out.println("请输入需要转换的金额：");
         
            //将输入的金额转化成long型的数据
         else
          {
            Money=Long.parseLong(agrs[n-1]);           
          }
          //bitt用于存放第几个需转换的金额数字，
          int bitt=0,j,k=-1,i=0;
         
          //转换过程
         while(Money!=0)
         {
          bitt=(int)(Money%10L);
           
          //计算出每个数字对应的大写值
          for(j=0;j<Mon.length;j++)
          {
            if(j==bitt)break;
          }
           
          //将相应的值存入je[]中
          if(k!=-1){je[i]=Mon1[k];i++;}
           je[i]=Mon[j];i++;            
           Money=Money/10;
          k++;
               if(Money==0)
                {
                 //输出转换后的金额
                 System.out.print("您输入的金额为：");
                 i--;
                 for(;i>=0;i--)
                 System.out.print(je[i]);
                }
               
       }
        
}
}

希望可以帮到你

你可以换个思想考虑，比如，把1换成大写的壹，依次对应，而大写的数字你可以先提前输入进去，然后检测到123……的时候，重新赋值过去

你这个两个思路，用余数每次/10 比如97/10就是7 ，在除/10就是9 然后吧这2个转换。另外一种转成String，然后利用switch遍历整个字符串。

董帅军 发表于 2014-8-14 08:52
1其实吧跟我们做的哪个基础差不多啊，就是把数字转化成大写数字，具体代码请参照

嗯嗯，谢谢了！

楼上给的代码转换出来的结果不太符合阅读习惯，稍微做了下改变，可以转换一亿以内数字

1. class Demo
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 System.out.print(ZhuanHuan(12345678));
   
6. 
   
7.         }
   
8. 
   
9.         // 数字转换，拆分
   
10.         public static StringBuilder ZhuanHuan(long num)
    
11.         {
    
12.                 StringBuilder sb = new StringBuilder();
    
13.                 if(num<10000)
    
14.                 {
    
15.                         sb=Siwei((int)num);
    
16.                 }
    
17.                 if((num>9999)&&(num<100000000))
    
18.                 {
    
19.                         sb.append(Siwei((int)(num/10000))).append("万").append(Siwei((int)(num%10000)));
    
20.                 }
    
21.                
    
22.                 return sb;
    
23.         }
    
24. 
    
25.         // 反转数组
    
26.         public static void reverseArray(int[] arr, int num)
    
27.         {
    
28.                 int tmp;
    
29.                 for (int start = 0, end = num - 1; start < end; start++, end--)
    
30.                 {
    
31.                         tmp = arr[start];
    
32.                         arr[start] = arr[end];
    
33.                         arr[end] = tmp;
    
34.                 }
    
35.         }
    
36. 
    
37.         // 四位数字读法
    
38.         public static StringBuilder Siwei(int num)
    
39.         {
    
40.                 String Ge[] = { "零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖" };
    
41.                 StringBuilder sb = new StringBuilder();
    
42.                 int js = 0;
    
43.                 int[] t = new int[4];
    
44.                 while (num != 0)
    
45.                 {
    
46.                         t[js] = num % 10;
    
47.                         num = num / 10;
    
48.                         js++;
    
49.                 }
    
50.                 reverseArray(t, js);
    
51.                 js = js - 1;
    
52.                 // 假如截取的数字是4位数
    
53.                 if (js == 3)
    
54.                 {
    
55.                         // 千位赋值
    
56.                         sb.append(Ge[t[js - 3]]);
    
57.                         sb.append("仟");
    
58.                         // 判断百位值
    
59.                         if (t[js - 2] != 0)
    
60.                         {
    
61.                                 sb.append(Ge[t[js - 2]]);
    
62.                                 sb.append("佰");
    
63.                                 if (t[js - 1] != 0)
    
64.                                 {
    
65.                                         sb.append(Ge[t[js - 1]]);
    
66.                                         sb.append("拾");
    
67.                                         if (t[js] != 0)
    
68.                                         {
    
69.                                                 sb.append(Ge[t[js]]);
    
70.                                         }
    
71.                                 } else
    
72.                                 {
    
73.                                         sb.append("零");
    
74.                                 }
    
75.                         } else
    
76.                         {
    
77.                                 sb.append("零");
    
78.                                 if (t[js - 1] != 0)
    
79.                                 {
    
80.                                         sb.append(Ge[t[js - 1]]);
    
81.                                         sb.append("拾");
    
82.                                         if (t[js] != 0)
    
83.                                         {
    
84.                                                 sb.append(Ge[t[js]]);
    
85.                                         }
    
86.                                 } else
    
87.                                 {
    
88.                                         if (t[js] != 0)
    
89.                                         {
    
90.                                                 sb.append(Ge[t[js]]);
    
91.                                         }
    
92.                                 }
    
93.                         }
    
94.                 }
    
95. 
    
96.                 // 判断截取数字是3位
    
97.                 if (js == 2)
    
98.                 {
    
99.                         sb.append(Ge[t[js - 2]]);
    
100.                         sb.append("佰");
     
101.                         if (t[js - 1] != 0)
     
102.                         {
     
103.                                 sb.append(Ge[t[js - 1]]);
     
104.                                 sb.append("拾");
     
105.                                 if (t[js] != 0)
     
106.                                 {
     
107.                                         sb.append(Ge[t[js]]);
     
108.                                 }
     
109.                         } else
     
110.                         {
     
111.                                 sb.append("零");
     
112.                                 if (t[js] != 0)
     
113.                                 {
     
114.                                         sb.append(Ge[t[js]]);
     
115.                                 }
     
116.                         }
     
117.                 }
     
118.                 // 判断截取数字是两位
     
119.                 if (js == 1)
     
120.                 {
     
121.                         sb.append(Ge[t[js - 1]]);
     
122.                         sb.append("拾");
     
123.                         if (t[js] != 0)
     
124.                         {
     
125.                                 sb.append(Ge[t[js]]);
     
126.                         }
     
127.                 }
     
128. 
     
129.                 // 判断截取数字是一位
     
130.                 if (js == 0)
     
131.                 {
     
132.                         sb.append(Ge[t[js]]);
     
133.                 }
     
134. 
     
135.                 return sb;
     
136.         }
     
137. 
     
138. }

复制代码

happymouse 发表于 2014-8-14 18:59
楼上给的代码转换出来的结果不太符合阅读习惯，稍微做了下改变，可以转换一亿以内数字
...

学习了，谢谢了！

liang926 发表于 2014-8-14 21:43
学习了，谢谢了！

不客气，共同进步