要求：编写一个程序，将浮点数转换成人民币读法字符串。例如：1235.22转换为壹仟贰佰叁拾伍元贰角贰分
          注意一点啊，如果是1005.22该怎么处理哦！！！

不得不说,看起来简单 其实写起来一点都不简单...

各种各种的毛病,首先是验证输入的信息是否是有效过,然后又要分是否有角分,再是对位数的插入,最后是对插入以后的数据进行准确的除零操作,我不说这有多坑爹...嘛 不过还是被我想出来了.

楼下各位的代码我很多都去测试了,首先不得不吐槽六楼(地板)的代码,连个入口都没有,这也就算了,起码可以当外类调用,可惜功能实在差点...7楼的还凑合,但是还不是很完善,没有输入功能也就罢了,不能没有角分是什么情况?没有角分就直接报错....太坑了..

然后是十楼的,不得不说,这段代码确实写的不错,可惜有些地方貌似判断错了,输入个2002.02,竟然给我说"贰仟零贰元壹分",估计是下标搞错了...不过还算强大..

写了我整整一个晚上,总算是完工了 自己测试了一堆 测试不出大问题 望有心人测试出来给我说下 我在这里谢过了!

最后贴代码!顺便求技术分!这么晚了不知道还有木有,但是这代码绝对手工,用心良苦,并且是这里功能最完善的代码!不信可以测试!

悲剧了 说是超过了长度限制,看了下超300 可怜 只能上传个打包的txt,直接复制里面的代码到新的工程就好,名字记得要改成一样的.

顺便老规矩

右键上面这个图 保存到随便一个你能找到的地方,然后更改后缀名为.rar然后解压,里面有写的很明白怎么用 可以就当测试,

最后是附件!求分!~~~ 阿拉伯数字转换成中文大写(直接复制这里的代码,核对下名字就可以跑了).rar.rar (2.43 KB, 下载次数: 172)

2012-11-3 20:18 上传

点击文件名下载附件

changenum.rar (2.85 KB, 下载次数: 163)

2012-11-2 17:07 上传

点击文件名下载附件

占楼写程序~~

写过一个整数的

[b]吃饱了 开始干活了 123哟    123哟

以前写过个整数的，再上面基础上改了改，显得代码很乱，但是基本上符合要求啦

1. import org.junit.Test;
   
2. 
   
3. public class Q10 {
   
4. 
   
5.         /**
   
6.          * @param dupengtao
   
7.          */
   
8.         @Test
   
9.         public void fun() {
   
10.                 final String[] s1 = { "零", "壹", "贰", "叁", "肆", "伍", "六", "七", "捌", "玖" };
    
11.                 // final String[] s2 = { "千亿","百亿","十亿","亿","千万","百万","十万", "万", "千",
    
12.                 // "百", "十","零" };
    
13.                 final String[] s2 = { "", "拾", "百", "千", "万", "拾", "百", "千", "亿", "拾",
    
14.                                 "百", "千", "万" };
    
15. 
    
16.                 final String[] s3 = { "分", "角" };
    
17.                 // TODO Auto-generated method stub
    
18.                 String m = null;
    
19.                 m = javax.swing.JOptionPane.showInputDialog(null, "请输入要转化成汉字的金额");
    
20.                 String[] money = m.split("\\.");
    
21.                 String in = money[0];
    
22.                 if (in != null) {
    
23.                         int length = in.length();
    
24.                         int l = length - 1;
    
25.                         boolean b = false;
    
26.                         StringBuilder sb = new StringBuilder();
    
27.                         for (int i = 0; i < length; i++) {
    
28.                                 switch (in.charAt(i)) {
    
29.                                 case '1': {
    
30.                                         sb.append(s1[1]);
    
31.                                         sb.append(s2[l--]);
    
32.                                         b = true;
    
33.                                 }
    
34.                                         break;
    
35.                                 case '2': {
    
36.                                         sb.append(s1[2]);
    
37.                                         sb.append(s2[l--]);
    
38.                                         b = true;
    
39.                                 }
    
40.                                         break;
    
41.                                 case '3': {
    
42.                                         sb.append(s1[3]);
    
43.                                         sb.append(s2[l--]);
    
44.                                         b = true;
    
45.                                 }
    
46.                                         break;
    
47.                                 case '4': {
    
48.                                         sb.append(s1[4]);
    
49.                                         sb.append(s2[l--]);
    
50.                                         b = true;
    
51.                                 }
    
52.                                         break;
    
53.                                 case '5': {
    
54.                                         sb.append(s1[5]);
    
55.                                         sb.append(s2[l--]);
    
56.                                         b = true;
    
57.                                 }
    
58.                                         break;
    
59.                                 case '6': {
    
60.                                         sb.append(s1[6]);
    
61.                                         sb.append(s2[l--]);
    
62.                                         b = true;
    
63.                                 }
    
64.                                         break;
    
65.                                 case '7': {
    
66.                                         sb.append(s1[7]);
    
67.                                         sb.append(s2[l--]);
    
68.                                         b = true;
    
69.                                 }
    
70.                                         break;
    
71.                                 case '8': {
    
72.                                         sb.append(s1[8]);
    
73.                                         sb.append(s2[l--]);
    
74.                                         b = true;
    
75.                                 }
    
76.                                         break;
    
77.                                 case '9': {
    
78.                                         sb.append(s1[9]);
    
79.                                         sb.append(s2[l--]);
    
80.                                         b = true;
    
81.                                 }
    
82.                                         break;
    
83.                                 case '0': {
    
84.                                         if (b) {
    
85.                                                 if (i != length - 1) {
    
86.                                                         if (l == 4) {
    
87.                                                                 sb.append("万");
    
88.                                                         }
    
89.                                                         if (l == 8) {
    
90.                                                                 sb.append("亿");
    
91.                                                         }
    
92.                                                         sb.append(s1[0]);
    
93.                                                         l--;
    
94.                                                 }
    
95.                                                 b = false;
    
96.                                         } else {
    
97.                                                 l--;
    
98.                                         }
    
99.                                 }
    
100.                                         break;
     
101.                                 }
     
102.                         }
     
103.                         String s = sb.toString();
     
104.                         if (s.charAt(s.length() - 1) == '零') {
     
105.                                 s = s.substring(0, s.length() - 1);
     
106.                         }
     
107.                         s += "元";
     
108.                         StringBuilder sb1 = new StringBuilder(s);
     
109.                         l = money[1].length() - 1;
     
110.                         boolean bol = false;
     
111.                         if (money[1].length() == 2) {
     
112.                                 for (int i = 0; i < money[1].length(); i++) {
     
113.                                         switch (money[1].charAt(i)) {
     
114.                                         case '1': {
     
115.                                                 sb1.append(s1[1]);
     
116.                                                 sb1.append(s3[l--]);
     
117.                                         }
     
118.                                                 break;
     
119.                                         case '2': {
     
120.                                                 sb1.append(s1[2]);
     
121.                                                 sb1.append(s3[l--]);
     
122.                                         }
     
123.                                                 break;
     
124.                                         case '3': {
     
125.                                                 sb1.append(s1[3]);
     
126.                                                 sb1.append(s3[l--]);
     
127.                                         }
     
128.                                                 break;
     
129.                                         case '4': {
     
130.                                                 sb1.append(s1[4]);
     
131.                                                 sb1.append(s3[l--]);
     
132.                                         }
     
133.                                                 break;
     
134.                                         case '5': {
     
135.                                                 sb1.append(s1[5]);
     
136.                                                 sb1.append(s3[l--]);
     
137.                                         }
     
138.                                                 break;
     
139.                                         case '6': {
     
140.                                                 sb1.append(s1[6]);
     
141.                                                 sb1.append(s3[l--]);
     
142.                                         }
     
143.                                                 break;
     
144.                                         case '7': {
     
145.                                                 sb1.append(s1[7]);
     
146.                                                 sb1.append(s3[l--]);
     
147.                                         }
     
148.                                                 break;
     
149.                                         case '8': {
     
150.                                                 sb1.append(s1[8]);
     
151.                                                 sb1.append(s3[l--]);
     
152.                                         }
     
153.                                                 break;
     
154.                                         case '9': {
     
155.                                                 sb1.append(s1[9]);
     
156.                                                 sb1.append(s3[l--]);
     
157.                                         }
     
158.                                                 break;
     
159.                                         case '0': {
     
160.                                                 sb1.append(s1[0]);
     
161.                                                 sb1.append(s3[l--]);
     
162.                                         }
     
163.                                                 break;
     
164.                                         }
     
165.                                 }
     
166.                                 // System.out.println(sb1);
     
167.                                 javax.swing.JOptionPane.showMessageDialog(null, sb1);
     
168.                         }
     
169.                 }
     
170.         }
     
171. }
     

复制代码

1. public class RMB {
   
2. 
   
3. 
   
4.         public static void main(String[] args) {
   
5.                 String floatNum = "120414210100856.73";
   
6.                 String[] alabo = floatNum.split("\\.");
   
7.                 String cNum = "中国大写数字为：";
   
8.                 char[] chars = alabo[0].toCharArray();
   
9.                 System.out.println("阿拉伯数字为："+new String(chars));
   
10.                 for (int i=0; i<chars.length; i++) {
    
11.                         //确定当前位的数字名称，只有零需要额外讨论
    
12.                         String numName = null;
    
13.                         if(chars[i] == '0'){
    
14.                                 if((chars.length - i) == 1)//如果零在个位上
    
15.                                         cNum += RMBNum.圆.toString();
    
16.                                 else if((chars.length - i)%4 == 1 && i != 0)//如果零在万、亿位上
    
17.                                         cNum += getUnit(chars, i).toString();
    
18.                                 else if(chars[i+1] != '0')//其他位上的零，只有下一位不是'0'才能输出零
    
19.                                         cNum += RMBNum.零.toString();
    
20.                         }else{
    
21.                                 numName = RMBNum.getCNum(chars[i]).toString();                                
    
22. 
    
23.                                 cNum += numName + getUnit(chars, i).toString();
    
24.                         }
    
25.                 }
    
26.                 //角、分
    
27.                 char[] jiao = alabo[1].toCharArray();
    
28.                 if(jiao[1]!='0'){//分位上不是零
    
29.                         cNum += RMBNum.getCNum(jiao[0]).toString() + RMBNum.角.toString() + RMBNum.getCNum(jiao[1]).toString() + RMBNum.分.toString();
    
30.                 }else if(jiao[0]!='0'){
    
31.                         cNum += RMBNum.getCNum(jiao[0]).toString() + RMBNum.角.toString();
    
32.                 }else{
    
33.                         cNum += RMBNum.整.toString();
    
34.                 }
    
35.                 System.out.println(cNum);
    
36.         }
    
37. 
    
38.         private static RMBNum getUnit(char[] chars, int i) {
    
39.                 //获得当前数字是从个位算起的第几位，除以8求余可以确定后面的单位。
    
40.                 RMBNum unitString = null;
    
41.                 int unitNum = (chars.length - i)%8;
    
42.                 switch (unitNum) {
    
43.                 case 1:
    
44.                         if((chars.length - i)!=1)
    
45.                                 unitString = RMBNum.亿;
    
46.                         else
    
47.                                 unitString = RMBNum.圆;                                       
    
48.                         break;
    
49.                 case 5:
    
50.                         unitString = RMBNum.万;
    
51.                         break;
    
52.                 case 2:
    
53.                 case 6:
    
54.                         unitString = RMBNum.拾;
    
55.                         break;
    
56.                 case 3:
    
57.                 case 7:
    
58.                         unitString = RMBNum.佰;
    
59.                         break;
    
60.                 case 0:
    
61.                 case 4:
    
62.                         unitString = RMBNum.仟;
    
63.                         break;
    
64.                 default:
    
65.                         break;
    
66.                 }
    
67.                 return unitString;
    
68.         }
    
69. 
    
70. }
    
71. 
    
72. enum RMBNum{
    
73.         零,壹,贰,叁,肆,伍,陆,柒,捌,玖,拾,佰,仟,万,亿,圆,角,分,整;
    
74. 
    
75.         public static RMBNum getCNum(char c){
    
76.                 switch (c) {
    
77.                 case '0':
    
78.                         return 零;
    
79.                 case '1':
    
80.                         return 壹;
    
81.                 case '2':
    
82.                         return 贰;
    
83.                 case '3':
    
84.                         return 叁;
    
85.                 case '4':
    
86.                         return 肆;
    
87.                 case '5':
    
88.                         return 伍;
    
89.                 case '6':
    
90.                         return 陆;
    
91.                 case '7':
    
92.                         return 柒;
    
93.                 case '8':
    
94.                         return 捌;
    
95.                 case '9':
    
96.                         return 玖;
    
97.                 }
    
98.                 return null;               
    
99.         }
    
100. }
     

复制代码

class Rmb
{
        public static void main(String[] args)
        {
               
                char[]  unitRmb={'分','角','元','拾','佰','仟','万'};
                char[] upperNum={'零','壹','贰','叁','肆','伍','陆','柒','捌','玖'};
                float floatNum = 1235.22f;
                String  floatStr= Float.toString(floatNum);
                int dotIndex=floatStr.indexOf(".");//小数点的位置
                String result="";
                System.out.println(unitRmb[1]);
                System.out.println(floatStr.charAt(0));
                int j=0;
                int k=0;
                for(int i=0;i<=dotIndex+2;i++)
                {        if(i!=dotIndex)
                        {
                        k++;
                        j=(int)floatStr.charAt(i)-48;//0的ASCII码为48
                result+=upperNum[j]+""+unitRmb[dotIndex+2-k];}
                        }
                        
                System.out.println("result:  "+result);
}
}

先占楼. 吃饭完在写

import java.util.*;   
class Num2Rmb {

/**
  * 此功能将一个浮点数转换成人民币读法字符串
  * 1 0000 0000
  * 亿   万    元
  * @param args
  * @author GuXiaojing
  */
//定义一个字符串数组
private String[] hanArr={"零","壹","贰","叁","肆","伍","陆","柒","捌","玖"};
private String[] unitArr={"拾","佰","仟"};
private String[] unitArr1={"元","万","亿"};
private String[] divide(double num){
  long zheng = (long)num;//整数部分
  
  long xiao = (int)((num-zheng)*100);//小数部分
  if((int)((num-zheng)*100)>=0&&(int)((num-zheng)*100)<10){
   return new String[]{zheng + "","0"+String.valueOf(xiao)};//把整数转换为字符串
  }else{
   return new String[]{zheng + "",String.valueOf(xiao)};//把整数转换为字符串
  }
  
}

private String toHanStr(String numStr){
  String result="";//结果
  int numLen = numStr.length();//数字字符串的长度
  
  //四位数开始
  if(numLen<=4){
   for (int i = 0;i<numLen;i++){
    int num = numStr.charAt(i)-48;//将char型数字减去48 得到int型数字
    if(num!=0){
     if(i!=numLen-1){
      result+=hanArr[num]+unitArr[numLen-2-i];//如果不是最后一位数则加上单位"拾","佰","仟"
     }else{
      result+=hanArr[num];
     }
    }else{
     if(i<numLen-1&&(numStr.charAt(i+1)-48!=0)){
      result+=hanArr[0];
     }
    }
   }
   if(result!=""){
    result+=unitArr1[0];
   }
  }else{//四位数结束
//   8位数开始
   if(numLen<=8){
    String qianW="";//定义一个千万以获取前四位的结果的字符串
    String endF="";//定义一个千位的字符串以获取后四位的结果
    for (int i = 0;i<numLen-4;i++){//取前四位
     int num = numStr.charAt(i)-48;//将char型数字减去48 得到int型数字
     if(num!=0){
      if(i!=numLen-5){
       qianW+=hanArr[num]+unitArr[numLen-6-i];//如果不是最后一位数则加上单位"拾","佰","仟"
      }else{
       qianW+=hanArr[num];
      }
     }else{
      if(i<numLen-1&&(numStr.charAt(i+1)-48!=0)){
       qianW+=hanArr[0];
      }
     }
    }
    if(qianW!=""){
     qianW+=unitArr1[1];
    }
    result+=qianW;
   
    //取后四位数
    for(int j=numLen-4;j<numLen;j++){
     int num = numStr.charAt(j)-48;//将char型数字减去48 得到int型数字
     if(num!=0){
      if(j!=numLen-1){
       endF+=hanArr[num]+unitArr[numLen-2-j];//如果不是最后一位数则加上单位"拾","佰","仟"
      }else{
       endF+=hanArr[num];
      }
     }else{
      if(j<numLen-1&&(numStr.charAt(j+1)-48!=0)){
       endF+=hanArr[0];
      }
     }
    }
    if(endF!=""){
     endF+=unitArr1[0];
    }
    result+=endF;
   }else{
   //8位结束
   
   //12位数开始
   if(numLen<=12){
    String yiW="";//定义一个以获取亿位前四位的结果的字符串
    String qianW="";//定义一个千万以获取前四位的结果的字符串
    String endF="";//定义一个千位的字符串以获取后四位的结果
    for (int k = 0;k<numLen-8;k++){//取前四位
     int num = numStr.charAt(k)-48;//将char型数字减去48 得到int型数字
     if(num!=0){
      if(k!=numLen-9){
       yiW+=hanArr[num]+unitArr[numLen-10-k];//如果不是最后一位数则加上单位"拾","佰","仟"
      }else{
       yiW+=hanArr[num];
      }
     }else{
      if(k<numLen-9&&(numStr.charAt(k+1)-48!=0)){
       yiW+=hanArr[0];
      }
     }
    }//前四位结束
    if(yiW!=""){
     yiW+=unitArr1[2];
    }
    result+=yiW;
    for (int i = numLen-8;i<numLen-4;i++){//取中间四位
     int num = numStr.charAt(i)-48;//将char型数字减去48 得到int型数字
     if(num!=0){
      if(i!=numLen-5){
       qianW+=hanArr[num]+unitArr[numLen-6-i];//如果不是最后一位数则加上单位"拾","佰","仟"
      }else{
       qianW+=hanArr[num];
      }
     }else{
      if(i<numLen-5&&(numStr.charAt(i+1)-48!=0)){
       qianW+=hanArr[0];
      }
     }
    }//中间四位结束
    if(qianW!=""){
     qianW+=unitArr1[1];
    }
    result+=qianW;
   
    //取后四位数
    for(int j=numLen-4;j<numLen;j++){
     int num = numStr.charAt(j)-48;//将char型数字减去48 得到int型数字
     if(num!=0){
      if(j!=numLen-1){
       endF+=hanArr[num]+unitArr[numLen-2-j];//如果不是最后一位数则加上单位"拾","佰","仟"
      }else{
       endF+=hanArr[num];
      }
     }else{
      if(j<numLen-1&&(numStr.charAt(j+1)-48!=0)){
       endF+=hanArr[0];
      }
     }
    }
    if(endF!=""){
     endF+=unitArr1[0];
    }
    result+=endF;
   }else{//12位结束
    System.out.println("本程序只能转换仟亿位（含）以下的数");
   
   }
  }
  }
  
  
  //返回结果
  return result;
  
}
//小数部分
private String toHanStrXiao(String numStr){
  String resultXiao="";
   if(numStr.charAt(0)-48==0){
    if(numStr.charAt(1)-48==0){
     resultXiao="";
    }else{
     resultXiao=hanArr[(numStr.charAt(1)-48)]+"分";
    }
   
   }else{
    if(numStr.charAt(1)-48!=0){
     resultXiao=hanArr[(numStr.charAt(0)-48)]+"角"+hanArr[(numStr.charAt(1)-48)]+"分";
    }else{
     resultXiao=hanArr[(numStr.charAt(0)-48)]+"角";
    }
   
   }
  return resultXiao;
}
public static void main(String[] args) {
  System.out.print("请输入金额:");
  Scanner input = new Scanner(System.in);
  double numDouble=input.nextDouble();
  Num2Rmb nr = new Num2Rmb();
  String[] num = nr.divide(numDouble);
  String result=nr.toHanStr(num[0])+nr.toHanStrXiao(num[1]);
  System.out.println(result);

}

}

import java.util.ArrayList;
import java.util.List;

/**
*  * @author zhangzhongbao
*/
public class MoneyTrans {

        /**
         * 主程序的入口
         *
         * @param args
         */
        public static void main(String[] args) {
                String money[] = Constant.departMoney("1235.22");
                if (money.length == 1) {
                        System.out.println(Constant.getYuan(money[0]) + "整");
                } else if (money.length == 2) {
                        System.out.print(Constant.getYuan(money[0]));
                        System.out.println(Constant.getFraction(money[1]));
                } else {
                        System.out.println("数字格式有误");
                }
        }

}

/**
* 将转换金额的类，做成一个工具类
* */
final class Constant {
        /**
         * 将构造方法私有，防止外部创建对象
         */
        private Constant() {
        }

        // 查表法的时候要用到
        public static String DIGIT[] = { "", "拾", "佰", "仟", "万", "拾万", "佰万", "仟万",
                        "亿", "拾亿", "佰亿", "仟亿", "万亿", "拾万亿" };
        public static String FRACTION[] = { "分", "角" };

        /**
         * 获取输入金额的整数部分
         * */
        public static String getYuan(String integer) {
                // 将整数部分转变成字符串
                char money[] = integer.toCharArray();
                // 当前指针指向DIGIT的位置
                int index = money.length - 1;
                // 用于存储将数字转换成汉字后的字符
                StringBuilder sb = new StringBuilder();
                // 也是存储转换后的字符，但是它的作用，主要是用来调用contains方法，来判断这个字符串时候存在
                List<String> list = new ArrayList<String>();

                for (int i = 0; i <= money.length - 1; i++) {
                        // 如果在数字中出现若干个连续的0，那么应该取这连续的0中的最后一个
                        if (i > 0 && money[i] == '0' && money[i - 1] == '0') {
                                index--;
                                continue;
                        }
                        // 获取转换后的字符
                        char ch = convertMoneyNumberToChinese(money[i]);
                        if (ch != '零') {
                                // 如果获取的字符不是‘零’，就可以在后面加上，仟"、"万"之类的信息
                                sb.append(ch + DIGIT[index]);
                                // 并且将字符存放到List集合中，以便于查找
                                list.add(DIGIT[index]);
                        } else {
                                // 如果是字符是‘零’，后面就不应该加上仟"、"万"之类的修饰
                                sb.append(ch);
                        }

                        index--;
                }
                String str = sb.toString();
                str = repalceString(list, str);
                return str + "圆";
        }

        /**
         * 以list str为参数，将字符串中出现重复的字符去掉，例如：出现“拾万”、“万”，这个时候，就应该去掉“拾万”中的“万”，留下“拾”
         *
         * @param list
         * @param str
         * @return
         */
        public static String repalceString(List<String> list, String str) {
                // 只有在集合和字符串里面有内容的时候才能操作
                if (list.size() > 0 && str.length() > 0) {
                        // 如果“拾万”和“万”一块出现，就应该将“拾万”中的”万“去掉
                        if (list.contains("拾万") && list.contains("万")) {
                                str = str.replaceAll("拾万", "拾");

                        }
                        // 如果”佰万“和“拾万”、“万”中的任意一个一块出现，就应该将“佰万”中的”万“去掉，留下“佰”
                        if (list.contains("佰万")
                                        && (list.contains("万") || list.contains("拾万"))) {
                                str = str.replaceAll("佰万", "佰");
                        }
                        // 如果“仟万”和”佰万“，“拾万”、“万”中的任意一个，一块出现，就应该将“仟万”中的”万“去掉，留下“仟”
                        if (list.contains("仟万")
                                        && (list.contains("万") || list.contains("拾万") || list
                                                        .contains("佰万"))) {
                                str = str.replaceAll("仟万", "仟");
                        }
                        // 如果“拾亿”和“亿”一块出现，就应该将“拾亿”中的”亿“去掉，留下“拾”
                        if (list.contains("拾亿") && list.contains("亿")) {
                                str = str.replaceAll("拾亿", "拾");
                        }
                        // 如果”佰亿“和“拾亿”、“亿”中的任意一个一块出现，就应该将“佰亿”中的”亿“去掉，留下“佰”
                        if (list.contains("佰亿")
                                        && (list.contains("亿") || list.contains("拾亿"))) {
                                str = str.replaceAll("佰亿", "佰");
                        }
                        // 如果“仟亿”和”佰亿“，“拾亿”、“亿”中的任意一个，一块出现，就应该将“仟亿”中的”亿“去掉，留下“仟”
                        if (list.contains("仟亿")
                                        && (list.contains("亿") || list.contains("拾亿") || list
                                                        .contains("佰亿"))) {
                                str = str.replaceAll("仟亿", "仟");
                        }
                        // 如果“拾万亿”和“万亿”一块出现，就应该将“拾万亿”中的”万亿“去掉
                        if (list.contains("拾万亿") && list.contains("万亿")) {
                                str = str.replaceAll("拾万亿", "拾");
                        }
                        // 如果最后一个字符为零，那么可以省略掉
                        if (str.charAt(str.length() - 1) == '零') {
                                str = str.substring(0, str.length() - 1);
                        }

                }
                return str;
        }

        /**
         * 获取金额的小数部分 为了以后的功能扩展使用，在一般开发中在利润方面一般用6位小数，而且是用数字来表示的，这里仅仅假定小数部分最多为两位
         *
         * @param fraction
         * @return
         */
        public static String getFraction(String fraction) {
                // 小数部分转换成字符串
                char money[] = fraction.toCharArray();
                int index = money.length - 1;// 指向末尾的
                StringBuilder sb = new StringBuilder();
                List<String> list = new ArrayList<String>();
                for (int i = 0; i < money.length; i++) {
                        // 如果在数字中出现若干个连续的0，那么应该取这连续的0中的最后一个
                        if (i > 0 && money[i] == '0' && money[i - 1] == '0') {
                                index--;
                                continue;
                        }
                        char ch = convertMoneyNumberToChinese(money[i]);
                        // 如果获取的字符不是‘零’，就可以在后面加上，“角"、"分"之类的信息
                        if (ch != '零') {
                                sb.append(ch + FRACTION[index]);
                                list.add(FRACTION[index]);
                        } else {
                                sb.append(ch);
                        }
                        index--;
                }
                String str = sb.toString();
                if (str.charAt(str.length() - 1) == '零') {
                        str = str.substring(0, str.length() - 1);
                }
                if ("".equals(str))
                        str = "整";
                return str;
        }

        /**
         * 将输入的金额
         *
         * @param money
         * @return
         */
        public static String[] departMoney(String money) {
                // 字符串为null时，抛出异常
                if (money == null)
                        throw new RuntimeException("您输入的数字为空");
                String regex1 = "[0-9]+\\.[0-9]{1,2}", regex2 = "[0-9]+";
                // 只要能匹配正则，就算是合格的
                if (money.matches(regex1) || money.matches(regex2)) {
                        return money.split("\\.");
                } else {
                        throw new RuntimeException("数字格式不正确");
                }
        }

        /**
         * 将数字变成汉字的大写形式
         *
         * @param temp
         * @return
         */
        private static char convertMoneyNumberToChinese(char temp) {
                char ch;
                switch (temp) {
                case '0':
                        ch = '零';
                        break;
                case '1':
                        ch = '壹';
                        break;
                case '2':
                        ch = '贰';
                        break;
                case '3':
                        ch = '叁';
                        break;
                case '4':
                        ch = '肆';
                        break;
                case '5':
                        ch = '伍';
                        break;
                case '6':
                        ch = '陆';
                        break;
                case '7':
                        ch = '柒';
                        break;
                case '8':
                        ch = '捌';
                        break;
                case '9':
                        ch = '玖';
                        break;
                default:
                        ch = '零';
                        break;
                }
                return ch;
        }
}

只要在Dos根据提示输入1005.22就可以出来结果。期待更简单的代码，这个太繁琐了

1. import java.math.BigDecimal;
   
2. 
   
3. public class RMBTest {
   
4. 
   
5.         public static void main(String[] args) {
   
6.                 //此处调用trans(double)方法，返回值即为转换后的中文数值字符串。
   
7.                 String s = trans(2011101230.37);
   
8.                 //打印。
   
9.                 System.out.println(s);
   
10.         }
    
11.        
    
12.         //该方法需要传入一个double类型的参数。
    
13.         public static String trans(double d) {
    
14.                 //本例设定最大转换值为999亿。若要输入更大的数据需要重新调整一下。这里做提示。
    
15.                 if(d > 99999999999.99) {
    
16.                         return "数值过大，请传入正确参数。";
    
17.                 }
    
18.                 //定义一个空字符串，最后该字符串作为返回值返回。
    
19.                 String returnValue = "";
    
20.                
    
21.                 /*
    
22.                  * 这里定义的两个字符数组作为查表使用。
    
23.                  * 其中bit作为单位，小数点位用空字符串代替。chinaNum作为数字。
    
24.                  */
    
25.                 final String[] bit = {"佰","拾","亿","仟","佰","拾","万","仟","佰","拾","元","","角","分"};
    
26.                 final String[] chinaNum = {"零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"};
    
27.                
    
28.        
    
29.                 /*
    
30.                  * 这里首先创建一个BigDecimal对象（因为普通的Double对象在超过百万后会变成科学计数，没办法进行转换）
    
31.                  * 然后调用BigDecimal对象的setScale方法，设定保留2位小数，四舍五入。
    
32.                  * 最后将其转换为字符串。举例：2011101230.37会被转换为：“2011101230.37”
    
33.                  */
    
34.                 String input = new BigDecimal(d).setScale(2,BigDecimal.ROUND_HALF_UP).toString();
    
35.                
    
36.                 //这里确定小数点的位置。查表时用到。
    
37.                 int index = input.indexOf(".");
    
38.                
    
39.                 //直接对输入的字符串进行遍历。
    
40.                 for(int i=0; i<input.length(); i++) {
    
41.                         /*
    
42.                          * 1、满足(i+1-index)%4==0的分别是万位、亿位，这也是为什么%4的原因。
    
43.                          * 2、满足这一位上的数是0
    
44.                          * 满足以上两点的举例：101111.11.万位是0，需要特殊处理，否则会出现零万的情况，不合理。
    
45.                          * 处理方式就是不把“零”加到字符串上。
    
46.                          */
    
47.                         if((i+1-index)%4==0 && input.charAt(i)=='0') {
    
48.                                 returnValue +=  bit[11-index+i];
    
49.                                 continue;
    
50.                         } else if(i==index || input.charAt(i)=='0') {
    
51.                                 continue;
    
52.                         }
    
53.                        
    
54.                         returnValue += chinaNum[Integer.parseInt(input.substring(i, i+1))] + bit[11-index+i];
    
55.                 }
    
56.                
    
57.                
    
58.                
    
59.                 return returnValue + "整";
    
60.         }
    
61. }

复制代码

写了好久

1. /*
   
2. * 要求：编写一个程序，将浮点数转换成人民币读法字符串。例如：1235.22转换为壹仟贰佰叁拾伍元贰角贰分.
   
3. * 思路:1.将浮点数先转成字符串,按.将其分成整数和小数部分分别处理;
   
4. * 2.再将字符串转成数字不停除10取模,商就是该位的单位math_units、模就是数字繁体字number_units;
   
5. * 3.用数组将单位和繁体字存起来,直接用角标找到即可.
   
6. * 几个问题:
   
7. * 1.零的问题,什么时候写零,怎么控制.
   
8. * 2.各种数字不合规范的验证
   
9. * 另外当数字是10、100000时输出是壹拾圆和壹拾万圆与口语不符，更改又得加很多判断
   
10. * 而且我觉得这个题目不该用float,它常常丢失精度导致输出的结果不对甚至报错如:999999.99,增加角分加了难度但带来了很多问题应该不是初衷
    
11. */
    
12. 
    
13. public class ChangeToRMB
    
14. {
    
15.         private static String[] math_units = { "", "拾", "佰", "仟", "万", "拾", "佰",
    
16.                         "仟", "亿", "拾", "佰", "仟", "万" };
    
17. 
    
18.         private static char[] number_units = { '零', '壹', '贰', '叁', '肆', '伍', '陆',
    
19.                         '柒', '捌', '玖' };
    
20.         // 专门定义一个boolean变量来控制打印结果中是否输出"零",一写零就赋false,一写繁体字就赋true
    
21.         private static boolean hasZero = false;
    
22. 
    
23.         private static StringBuffer countIntPart(String s)
    
24.         {
    
25.                 int mathIndex = 0;
    
26.                 StringBuffer sb = null;
    
27.                 int temp = Integer.parseInt(s);
    
28.                 int remainder = temp % 10;
    
29.                 if (temp == 0)
    
30.                         return null;
    
31.                 else
    
32.                         sb = new StringBuffer("圆");
    
33.                 // 其实mathIndex取不到11即千亿级别,float早就改用科学计数法表示了
    
34.                 for (; temp / 10 > 0 && mathIndex < 12; temp = temp / 10, remainder = temp % 10, mathIndex++)
    
35.                 {
    
36.                         if (remainder == 0)
    
37.                         {
    
38.                                 if (hasZero)
    
39.                                 {
    
40.                                         sb.append("零");
    
41.                                         hasZero = false;
    
42.                                 }
    
43.                                 /* 这里单独在mathIndex为4时加个万字,是数字大于1万而万位刚好为0时会导致打印结果缺失万字*/
    
44.                                 if (mathIndex == 4)
    
45.                                 {
    
46.                                         sb.append("万");
    
47.                                 }
    
48.                         }
    
49.                         else if (remainder != 0)
    
50.                         {
    
51.                                 sb.append(math_units[mathIndex]);
    
52.                                 sb.append(number_units[remainder]);
    
53.                                 hasZero = true;
    
54.                         }
    
55.                 }
    
56.                 hasZero = true;
    
57.                 sb.append(math_units[mathIndex]);
    
58.                 sb.append(number_units[remainder]);
    
59.                 sb = sb.reverse();
    
60.                 return sb;
    
61.         }
    
62. 
    
63.         /* 对小数部分进行操作 */
    
64.         private static String countPointPart(String s)
    
65.         {
    
66.                 String str = null;
    
67.                 if (s.length() > 2)
    
68.                 {
    
69.                         System.out.println("最多只能精确到分,多余的部分将舍弃!");
    
70.                 }
    
71.                 s = s + "0"; // 浮点型可能将多位小数变成一位,导致从0-2位取值时错误,所以在字符串后面加个0
    
72.                 int temp = Integer.parseInt(s.substring(0, 2));
    
73.                 if (temp == 0)
    
74.                 {
    
75.                         return null;
    
76.                 }
    
77.                 else if (temp / 10 > 0)
    
78.                 {
    
79.                         str = number_units[temp / 10] + "角";
    
80.                         if (temp % 10 != 0)
    
81.                         {
    
82.                                 str = str + number_units[temp % 10] + "分";
    
83.                         }
    
84.                 }
    
85.                 else if (hasZero)
    
86.                 {
    
87. 
    
88.                         str = "零" + number_units[temp] + "分";
    
89.                 }
    
90.                 else
    
91.                 {
    
92.                         str = number_units[temp] + "分";
    
93.                 }
    
94.                 hasZero = false;
    
95.                 return str;
    
96.         }
    
97. 
    
98.         private static void change(float f)
    
99.         {
    
100.                 if (f < 0)
     
101.                 {
     
102.                         System.out.println("您输入的数字不合法!");
     
103.                         return;
     
104.                 }
     
105.                 if (String.valueOf(f).contains("E")) // 数字过大时会用科学计数法表示导致错误发生
     
106.                 {
     
107.                         System.out.println("您输入的数字过大,无法转换!");
     
108.                         return;
     
109.                 }
     
110.                 String[] arr = String.valueOf(f).split("\\.");
     
111.                 StringBuffer sbInt = countIntPart(arr[0]);
     
112.                 String s = countPointPart(arr[1]);
     
113.                 StringBuffer sbPoint = null;
     
114.                 /* 将两部分合并时可能有一部分是null,必须分开讨论 */
     
115.                 if (s != null)
     
116.                 {
     
117.                         sbPoint = new StringBuffer(s);
     
118.                 }
     
119.                 if (f == 0)
     
120.                 {
     
121.                         System.out.println("零");
     
122.                 }
     
123.                 else if (sbInt != null && sbPoint != null)
     
124.                 {
     
125.                         System.out.println(sbInt.append(sbPoint));
     
126.                 }
     
127.                 else if (sbInt == null)
     
128.                 {
     
129.                         System.out.println(sbPoint);
     
130.                 }
     
131.                 else
     
132.                         System.out.println(sbInt);
     
133.         }
     
134. 
     
135.         public static void main(String[] args)
     
136.         {
     
137.                 float f1 = 670005.87f;
     
138.                 float f2 = 1005.22f;
     
139.                 float f3 = 123056.05f;
     
140. //                System.out.println(f1);
     
141. //                System.out.println(f2);
     
142. //                System.out.println(f3);
     
143.                 change(f1);
     
144.                 change(f2);
     
145.                 change(f3);
     
146.         }
     
147. }
     

复制代码

这个题写的很累 我写不出

朱宏青 发表于 2012-11-2 15:37
不得不说,看起来简单 其实写起来一点都不简单...

各种各种的毛病,首先是验证输入的信息是否是有效过,然后 ...

首先谢谢你看过我的代码，我用的junit的测试框架，程序是没有入口函数可以直接执行的，你可以再函数上的注解上看得出来啊！
我以后会自习优化自己的代码的，我承认我是为了图快，在以前写的代码上继续添加的。写好后没有优化自己的代码，但是也是我认真编写的，也花了心血，我以后一定会注意优化代码！我的功能其实都实现了，自己做了测试，并不像你说的那样。