A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© Rain2692 高级黑马   /  2014-12-18 12:34  /  1853 人查看  /  14 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

金额转换,阿拉伯数字转换成中国传统形式。例如:101000001010 转换为壹仟零壹拾亿零壹仟零壹拾圆整,经过好几次的测试,将所有可能的出现的问题都处理干净了,数字的最大限制是万亿,当然,也可以在我的基础上进行扩充。
  1. static char[] CharArray={'零','壹','贰','叁','肆','伍','陆','柒','捌','玖'};
  2.         static char[] UnitArray_1={' ','拾','佰','仟'};
  3.         static char[] UnitArray_2={'亿','萬','圆'};
  4.         static char[] arr;
  5.         static boolean flag =false;
  6.         static String str =null;
  7.         static String NewChar = "零";
  8.         static StringBuffer sb =new StringBuffer();
  9.         public static void main(String[] args) throws IOException {
  10.                 // TODO Auto-generated method stub
  11.            int len=0;
  12.        BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
  13.        String line = null;
  14.        while((line = bufr.readLine())!=null)
  15.        {
  16.                arr = line.toCharArray();
  17.                len=arr.length;
  18.                      if(len>8)
  19.                      {   
  20.                              sb.delete(0,sb.length());
  21.                              str =null;
  22.                              for(int i=len-8,j=0,count=0;i<=len;)
  23.                              {
  24.                                      arr = line.substring(j, i).toCharArray();
  25.                                       Conver(arr.length);  
  26.                                       if(flag)
  27.                                           sb.append((char)UnitArray_2[count]);
  28.                                    
  29.                                  j=i;
  30.                                  i=i+4;
  31.                                  count++;
  32.                              }
  33.                              sb.append('整');
  34.                      }
  35.                      
  36.                  else if(len<=8 && len>4)
  37.                  {
  38.                          sb.delete(0,sb.length());
  39.                          str =null;
  40.                          for(int i=len-4,j=0,count=1;i<=len;)
  41.                          {
  42.                                  arr = line.substring(j, i).toCharArray();
  43.                                   Conver(arr.length);  
  44.                                       sb.append((char)UnitArray_2[count]);
  45.                                
  46.                              j=i;
  47.                              i=i+4;
  48.                              count++;
  49.                          }
  50.                          sb.append('整');
  51.                  }
  52.                  else
  53.                  {
  54.                          sb.delete(0,sb.length());
  55.                          str =null;
  56.                          for(int i=len,j=0,count=2;i<=len;)
  57.                          {
  58.                                  arr = line.substring(j, i).toCharArray();
  59.                                   Conver(arr.length);  
  60.                                       sb.append((char)UnitArray_2[count]);
  61.                                
  62.                              j=i;
  63.                              i=i+4;
  64.                              count++;
  65.                          }
  66.                          sb.append('整');                 
  67.                  }

  68.              Contains();
  69.                  System.out.println(str);
  70.        }
  71.   }
  72.       


  73.   //转换函数
  74.   public static void Conver(int len)
  75.          {
  76.                  flag= false;
  77.                  for(int i=0;i<len;i++)
  78.                  {
  79.                          int num = arr[i]-'0';
  80.          
  81.                          if(i!=len-1)
  82.                          sb.append((char)CharArray[num]);
  83.                          else{
  84.                                  if(num!=0)
  85.                                          {
  86.                                            sb.append((char)CharArray[num]);
  87.                                            flag =true;
  88.                                          }
  89.                                  else
  90.                                          break;
  91.                          }
  92.                          if(num!=0)
  93.                                  {
  94.                                     sb.append(UnitArray_1[len-i-1]);
  95.                                     flag =true;
  96.                                  }       
  97.                          
  98.                 }
  99.                  if(!flag)
  100.                  {
  101.                          sb.delete(sb.length()-len+2, sb.length()+1);
  102.                  }
  103.          
  104. }
  105.          
  106. //去除多余的成分         
  107. public static void Contains()
  108. {
  109.         if(sb.charAt(sb.length()-3) =='零')
  110.        sb=sb.replace(sb.length()-3, sb.length(), "圆整");
  111.                
  112.                 str=sb.toString();
  113.                
  114.                 //循环直到不再存在"零零"的情况
  115.             while(str.contains("零零"))
  116.                 {
  117.                   if(str.contains("零零"))
  118.                      str =str.replace("零零", NewChar);
  119.                 }

  120.                  //在亿的位置上会出现问题
  121.                    int index =str.indexOf("亿")-1;
  122.                    if(index>=0)
  123.                    {
  124.                          if(str.charAt(index)=='零')
  125.                                 str = str.substring(0, index)+str.substring(index+1,str.length());
  126.                          
  127.                    }
  128.                
  129.                  //在萬的位置上会出现问题
  130.                   index =str.indexOf("萬")-1;
  131.                   if(index>0)
  132.                   {
  133.                         if(str.charAt(index)=='零')
  134.                                 str = str.substring(0, index)+str.substring(index+1,str.length());
  135.                   }
  136.                   
  137.                   //在圆的位置上会出现问题
  138.                   index =str.indexOf("圆")-1;
  139.                   if(index>0)
  140.                   {
  141.                         if(str.charAt(index)=='零')
  142.                                 str = str.substring(0, index)+str.substring(index+1,str.length());
  143.                   }
  144.                
  145.          }
  146.                        
复制代码



14 个回复

倒序浏览
先占一个沙发。。。
回复 使用道具 举报
好膩害的樣子
回复 使用道具 举报
表示我还不会,学完java能写的出来吧
回复 使用道具 举报
这个是我做的代码。。然后想要做的更好的话觉得应该加上小数部分也就是角和分。。虽然我没加上。。

  1. /*
  2. 10、  金额转换,阿拉伯数字转换成中国传统形式。
  3.     例如:101000001010   转换为   壹仟零壹拾亿零壹仟零壹拾圆整
  4.     思路:
  5. 1.因为样例中的数据过大并不能以int、long存储,所以考虑直接存储为字符串后进行转化
  6. 2.定义char数组保存中文数字.定义String数组保存中文位数。将输入的数字转化为中文数字并保存。
  7. 3.继续遍历中文数字的数组,将其添加进字符串缓冲区同时补上代表位数的中文
  8. 4.将需要去零的地方用String的replaceAll方法去除。用正则表达式匹配

  9. */

  10. public class Test10
  11. {
  12.         public static void main(String[] args)
  13.         {
  14.                 String moneyNum="101000001010";
  15.                 System.out.println(transToCn(moneyNum));//结果为壹仟零壹拾亿零壹仟零壹拾圆整

  16.                 moneyNum="230054080";
  17.                 System.out.println(transToCn(moneyNum));//结果为贰亿叁仟零伍万肆仟零捌拾圆整

  18.                 moneyNum="10000";
  19.                 System.out.println(transToCn(moneyNum));//结果为壹万圆整       
  20.         }

  21.         private static String transToCn(String moneyNum)
  22.         {
  23.                 //因为中文数字和中文位都是固定的,所以用终态修饰
  24.                 final char[] CN_NUM=new char[]{'零','壹','贰','叁','肆','伍','陆','柒','捌','玖'};
  25.                 final String[] CN_WEI=new String[]{"圆","拾","佰","仟","万","拾","佰","仟","亿","拾","佰","仟"};
  26.                
  27.                 //将输入的金额转换为字符数组保存
  28.                 char[] chs=moneyNum.toCharArray();
  29.                
  30.                 //根据保存的金额数将其所有位对应转化成中文数字
  31.                 for(int i=0;i<chs.length;i++)
  32.                 {
  33.                         chs[i]=CN_NUM[Integer.parseInt(String.valueOf(chs[i]))];
  34.                 }
  35.                
  36.                 StringBuilder sb=new StringBuilder();//创建字符串缓冲区
  37.                 for(int i=0;i<chs.length;i++)
  38.                 {
  39.                         sb.append(chs[i]);//将中文数字加入缓冲区
  40.                         sb.append(CN_WEI[chs.length-i-1]);//将对应的位数表示加入缓冲区。因为数组从0计数所以要减去1
  41.                 }
  42.                 sb.append("整");//数据加完了加上整
  43.                
  44.                 String str=sb.toString();//将缓冲区转换成字符串以便去零和返回
  45.                
  46.                 str=str.replaceAll("零[拾佰仟]", "零");//去除亿万千圆中间的零
  47.                 str=str.replaceAll("零{4}万", "零");//万前有4个零万就不显示万
  48.                 str=str.replaceAll("零+亿","亿").replaceAll("零+万","万").replaceAll("零+圆","圆");//去除亿、万圆后的零
  49.                 str=str.replaceAll("零+","零");//有多个零就只保留一个
  50.                
  51.                 return str;
  52.                
  53.         }
  54. }
复制代码
回复 使用道具 举报
只是还不充分。来这里学习。
回复 使用道具 举报
冥夜 发表于 2014-12-18 13:34
这个是我做的代码。。然后想要做的更好的话觉得应该加上小数部分也就是角和分。。虽然我没加上。。
...

思路很清晰啊,不错,如果可以循环输入就更好了。。。
回复 使用道具 举报
冥夜 中级黑马 2014-12-18 15:03:59
8#
Rain2692 发表于 2014-12-18 14:49
思路很清晰啊,不错,如果可以循环输入就更好了。。。

想循环输入就用scanner呗
回复 使用道具 举报
楼主你这个才到1千亿啊 我要是输入个1兆的话你这个就崩溃了啊
回复 使用道具 举报 1 0
wangcongwu 发表于 2014-12-18 15:31
楼主你这个才到1千亿啊 我要是输入个1兆的话你这个就崩溃了啊

是一万亿好吧,你可以进行修改。。。不是都说了吗
回复 使用道具 举报
给你们看我的吧,我这个可以到Long 的最大值基本上
  1. import java.nio.ShortBuffer;
  2. import java.sql.Array;
  3. import java.util.*;
  4. //
  5. /*金额转换,阿拉伯数字转换成中国传统形式。例如:

  6. 101000001010

  7. 转换为壹仟零壹拾亿零壹仟零壹拾圆整*/


  8. public class MoneyCaseChangev1 {

  9.         public static void main(String[] args) {

  10.                 //先将输入的数字转化为int类型的数组
  11.         //        Long num = 56789L ;// 壹仟零壹拾亿陸仟零零万壹仟零壹拾圆//零零万转化为万零
  12. // 注意是Long 的数值最后要加入L
  13.                 Long num1 = 1010000010101010112L;//壹拾壹万亿零壹佰零亿零零零万壹仟零壹拾圆 //零亿转化为亿零

  14.                 //Long num2 = 101000001010L; //壹仟零壹拾亿零零零万壹仟零壹拾圆//零零零万转化为零      零零零亿转化为零
  15.             //创建哈希表存放对应的0到9 的大写中文
  16.                         HashMap<Integer,String> hm = new HashMap<Integer,String>();
  17.                         hm.put(9, "玖");
  18.                         hm.put(8,"捌");
  19.                         hm.put(7, "柒");
  20.                         hm.put(6, "陸");
  21.                         hm.put(5,"伍" );
  22.                         hm.put(4, "肆");
  23.                         hm.put(3, "叁");
  24.                         hm.put(2, "贰");
  25.                         hm.put(1, "壹");
  26.                         hm.put(0, "零");
  27.                
  28.                   String str = num1.toString();// 转化为字符串
  29.                   int[] intArray = new int[str.length()];// 新建一个数组用来保存num每一位的数字
  30.                   for (int i = 0; i < str.length(); i++) {
  31.                    // 遍历str将每一位数字添加如intArray
  32.                    Character ch = str.charAt(i);
  33.                    intArray[i] = Integer.parseInt(ch.toString());
  34.                   }

  35.                 //创建一个stringbuffer 类存放没一个大写中文数字和其对应的个十百千万亿等单位数
  36.                 StringBuffer sb = new StringBuffer();
  37.                 for(int i = 0;i<intArray.length;i++)
  38.                 {
  39.                         int pos = intArray.length - i;
  40.                         int yu = pos %4;
  41.                        
  42.                 if(intArray[i] == 0 && yu != 1)//把不在第五位的零放进去
  43.                           sb.append(hm.get(intArray[i]));
  44.                 else if(intArray[i] == 0 && yu == 1)//把在第五位并且等于1 的零的单位放进去
  45.                 {
  46.                         sb.append(Units(intArray[i],pos));
  47.                 }
  48.                 else sb.append(hm.get(intArray[i])+Units(intArray[i],pos));//把剩下的其他位置的零都放进去

  49.             }
  50.                
  51.                 String s = sb.toString();
  52.        
  53.                 //调用去掉零的犯法,必须两次,不然还有不必要的零出现
  54.                 String s1 = DeZ1(s);
  55.                 String s2 = DeZ(s1);
  56.                 String s3 = DeZ(s2);
  57.                 String s4 = DeZ1(s3);
  58.                 String s5 = DeZ(s4);

  59.                 //输出最终的大写中文钱数
  60.             sop(s5+"整");

  61.         }
  62.        
  63.         public static String DeZ1(String s)
  64.         {
  65.        
  66.                StringBuffer sb = new StringBuffer(s);
  67.                 int i = 0;
  68.                 while(sb.charAt(i) =='零'&&sb.charAt(i+1) =='零')
  69.                 {
  70.                          sb.deleteCharAt(i);
  71.                          i++;
  72.                 }
  73.                
  74.                 return sb.toString();
  75.         }
  76.         //多余的零去掉或者放在万的后面
  77.         public static String DeZ(String s )
  78.         {
  79.                    s = s.replace("零零零亿", "零");
  80.                    s = s.replace("零零零万", "零");
  81.                    //s = s.replace("零零零零零", "零");
  82.                    //s = s.replace("零零零零", "零");
  83.                    //s = s.replace("零零零", "零");;
  84.                    s = s.replace("零零", "零");
  85.                    //s = s.replace("零零万", "万零");
  86.                    s = s.replace("零万", "万零");
  87.                   // s = s.replace("零零亿", "亿零");
  88.                    s = s.replace("零亿", "亿零");

  89.                 return s;
  90.         }
  91.            //自己编写的输出打印类
  92.         public static void sop(Object obj)
  93.         {
  94.                 System.out.print(obj);
  95.                 System.out.println();
  96.     }
  97.       //单位类,以4个位数为一个周期,在四的位置为钱,在3的位置为百,在第二的位置为十,在最后一位不是圆就是万,或者 亿,或者万和亿的组合。
  98.         public static String Units(int value ,int pos)
  99.         {
  100.                 HashMap<Integer,String> hm = new HashMap<Integer,String>();
  101.                 hm.put(0, "仟");
  102.                 hm.put(3, "佰");
  103.                 hm.put(2, "拾");
  104.                
  105.                 int yu = pos%4;

  106.                 if(value != 0 && yu != 1 )
  107.                 {
  108.                         return hm.get(yu);
  109.                
  110.                 }
  111.                 if(yu == 1)
  112.                         return yu1dejihe(pos);
  113.                 return "";
  114.         }       
  115.          //在每四个数字周期的最后一个节点,要讨论是圆,还是亿还是万
  116.         public static String yu1dejihe(int pos)
  117.         {
  118.                 int poschusi = pos/4;
  119.                 if(poschusi ==0)
  120.                 {
  121.                         return "圆";
  122.                 }
  123.                 if(poschusi == 1)
  124.                 {
  125.                         return "万";
  126.                 }
  127.                 if(poschusi == 2)
  128.                 {
  129.                         return "亿";
  130.                 }
  131.                 return mei(pos);
  132.         }
  133.         // 如果是很多位数,超过了万亿等,要讨论到底在哪个位置放万,在哪个位置放亿,有多少个亿要放,
  134.         public static String mei(int pos)
  135.         {
  136.                 StringBuffer sb = new StringBuffer();
  137.                 StringBuffer sbw = new StringBuffer();
  138.                
  139.                 sbw.append("万");
  140.                
  141.                 int posyu8 = pos%8;
  142.                
  143.                
  144.                 if(posyu8 ==5)
  145.                 {
  146.                         return sbw.toString();
  147.                 }
  148.                 if(posyu8 == 1)
  149.                 {
  150.                         int poschu8 = pos/8;
  151.                         for(int i = 0; i<poschu8 ;i++)
  152.                         {
  153.                                 sb.append('亿');
  154.                         }
  155.                 }
  156.                 return sb.toString();
  157.         }
  158. }
复制代码
回复 使用道具 举报
Rain2692 发表于 2014-12-18 15:41
是一万亿好吧,你可以进行修改。。。不是都说了吗

你的到不了万亿吧 我试了不行啊
回复 使用道具 举报
godmmm 高级黑马 2014-12-18 16:41:52
13#

RE: 入学测试题目(钱的转换问题)

本帖最后由 godmmm 于 2014-12-18 16:43 编辑

都是大婶,参照楼上大婶们的思路我也写了一下,有点难啊!

  1. import java.io.*;
  2. public class AmountOfConversion {
  3. public static void main(String[] args) throws IOException {
  4. BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));//键盘录入
  5. String Amount=null;//定义金额字符串
  6. while((Amount=bufr.readLine())!=null)//读取键盘的一行
  7. {
  8. if(Amount.length()>12)//限制数据的最大长度不超过12位
  9. {
  10. System.out.println("数据超出范围");//超过12位提示、并返回重新读取键盘录入
  11. continue;
  12. }
  13. try{
  14. Long log=Long.parseLong(Amount);//将字符串转化为长整型数据,解决了输入数据是字母的情况
  15. Amount=new String(log+"");//转化后将值变为字符串赋值给Amount,这样解决了输入数据是0开头的情况
  16. }
  17. catch(Exception e)
  18. {
  19. System.out.println("数据有误");//不符合时提示数据有误,并返回重新读取键盘录入
  20. continue;
  21. }
  22. char[] crr=Amount.toCharArray();//字符串变为字符数组
  23. StringBuilder sb=new StringBuilder();//定义字符串缓存区
  24. char[] Number=new char[]{'零','壹','贰','叁','肆','伍','陆','柒','捌','玖'};//定义中文数字数组
  25. char[] Unit=new char[]{'整','拾','佰','仟','萬','拾','佰','仟','亿','拾','佰','仟'};//定义中文单位数组
  26. for(int x=0;x<crr.length;x++)
  27. {
  28. int y = Integer.parseInt(crr[x] + "");// 获取数字
  29. sb.append(Number[y]+""+Unit[crr.length-x-1]);//数字查表查出对应的中文数字和单位添加到缓存区
  30. }
  31. System.out.println(sb.toString());//打印出数字对应的中文
  32. String CNAmount=sb.toString();//取出中文数字
  33. CNAmount=CNAmount.replaceAll("零[佰拾仟]", "零");//正则替换
  34. CNAmount=CNAmount.replaceAll("零+", "零");//正则替换
  35. CNAmount=CNAmount.replaceAll("零+亿", "亿").replaceAll("零+萬", "萬").replaceAll("零+整", "整");//正则替换
  36. System.out.println(Amount);//打印录入的数字
  37. System.out.println(CNAmount);//打印转换的中文数字
  38. }
  39. }
  40. }
复制代码


回复 使用道具 举报
大神啊!!
回复 使用道具 举报
学习了,谢谢分享!
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马