Java中实现将数字转换成中文金额大写形式

实现程序示例一:
 
Java代码
  1.   
  2. /**  
  3.  * 程序目的:  
  4.  *   从命令行接收一个数,并将其转化为中文金额的大写方式  
  5.  * 例如 123.45 –> 壹佰贰拾叁元肆角伍分   
  6.  * 
  7.  *   
  8.  *   程序的注释我尽量写得详细一点,如果觉得这个程序哪里有问题或者是哪里有改进的  
  9.  * 地方欢迎随时跟我交流。  
  10.  *  
  11.  *    
  12.  * 我的blog:http://lzw.me
  13.  * 欢迎交流  
  14.  */  
  15. public class Trans2RMB {   
  16.   
  17.     /**  
  18.      * 测试程序的可行性  
  19.      * @param args  
  20.      */  
  21.     public static void main(String[] args) {   
  22.         System.out.println("n——–将数字转换成中文金额的大写形式————n");   
  23.         Trans2RMB t2r = new Trans2RMB();   
  24.         String s = t2r.cleanZero(t2r.splitNum(t2r.roundString(t2r.getNum())));   
  25.         // 如果转换过后是一个空串,则不输出屏幕   
  26.         if(!"".equals(s)) {   
  27.             System.out.println("转换成中文后为:" + s);;   
  28.         }   
  29.         System.out.println("n———————————————");   
  30.     }   
  31.        
  32.     /**  
  33.      * 从命令行接收一个数,在其中调用 checkNum() 方法对其进行  
  34.      * 验证,并返回相应的值  
  35.      * @return 如果输入合法,返回输入的这个数  
  36.      */  
  37.     private String getNum() {   
  38.         String s = null;   
  39.         System.out.println("请输入一个数字(精确到小数点后两位):");   
  40.         // 从命令行输入这个浮点数   
  41.         java.util.Scanner scanner = new java.util.Scanner(System.in);   
  42.         s = scanner.next();   
  43.         // 关闭这个Scanner   
  44.         scanner.close();   
  45.         // 判断用户输入是否合法   
  46.         // 若合法,返回这个值;若非法返回 "0"   
  47.         if(this.checkNum(s)) {   
  48.             return s;   
  49.         } else {   
  50.             return "";   
  51.         }   
  52.     }   
  53.        
  54.     /**  
  55.      * 判断用户输入的数据是否合法,用户只能输入大于零的数字,不能输入其它字符  
  56.      * @param s String  
  57.      * @return 如果用户输入数据合法,返回 true,否则返回 false  
  58.      */  
  59.     private boolean checkNum(String s) {   
  60.         // 如果用户输入的数里有非数字字符,则视为非法数据,返回 false   
  61.         try {   
  62.             float f = Float.valueOf(s);   
  63.             // 如果这个数小于零则视为非法数据,返回 false   
  64.             if(f < 0) {   
  65.                 System.out.println("非法数据,请检查!");   
  66.                 return false;   
  67.             }else {   
  68.                 return true;   
  69.             }   
  70.         } catch (NumberFormatException e) {   
  71.             System.out.println("非法数据,请检查!");   
  72.             return false;   
  73.         }      
  74.     }   
  75.        
  76.     /**  
  77.      * 把用户输入的数以小数点为界分割开来,并调用 numFormat() 方法  
  78.      * 进行相应的中文金额大写形式的转换  
  79.      * 注:传入的这个数应该是经过 roundString() 方法进行了四舍五入操作的  
  80.      * @param s String  
  81.      * @return 转换好的中文金额大写形式的字符串  
  82.      */  
  83.     private String splitNum(String s) {   
  84.         // 如果传入的是空串则继续返回空串   
  85.         if("".equals(s)) {   
  86.             return "";   
  87.         }   
  88.         // 以小数点为界分割这个字符串   
  89.         int index = s.indexOf(".");   
  90.         // 截取并转换这个数的整数部分   
  91.         String intOnly = s.substring(0, index);   
  92.         String part1 = this.numFormat(1, intOnly);   
  93.         // 截取并转换这个数的小数部分   
  94.         String smallOnly = s.substring(index + 1);   
  95.         String part2 = this.numFormat(2, smallOnly);   
  96.         // 把转换好了的整数部分和小数部分重新拼凑一个新的字符串   
  97.         String newS = part1 + part2;   
  98.         return newS;   
  99.     }   
  100.            
  101.     /**  
  102.      * 对传入的数进行四舍五入操作  
  103.      * @param s String 从命令行输入的那个数  
  104.      * @return 四舍五入后的新值  
  105.      */  
  106.     private String roundString(String s) {   
  107.         // 如果传入的是空串则继续返回空串   
  108.         if("".equals(s)) {   
  109.             return "";   
  110.         }   
  111.         // 将这个数转换成 double 类型,并对其进行四舍五入操作   
  112.         double d = Double.parseDouble(s);   
  113.         // 此操作作用在小数点后两位上   
  114.         d = (d * 100 + 0.5) / 100;   
  115.         // 将 d 进行格式化   
  116.         s = new java.text.DecimalFormat("##0.000").format(d);   
  117.         // 以小数点为界分割这个字符串   
  118.         int index = s.indexOf(".");   
  119.         // 这个数的整数部分   
  120.         String intOnly = s.substring(0, index);   
  121.         // 规定数值的最大长度只能到万亿单位,否则返回 "0"   
  122.         if(intOnly.length() > 13) {   
  123.             System.out.println("输入数据过大!(整数部分最多13位!)");   
  124.             return "";   
  125.         }   
  126.         // 这个数的小数部分   
  127.         String smallOnly = s.substring(index + 1);   
  128.         // 如果小数部分大于两位,只截取小数点后两位   
  129.         if(smallOnly.length() > 2) {   
  130.             String roundSmall = smallOnly.substring(02);   
  131.             // 把整数部分和新截取的小数部分重新拼凑这个字符串   
  132.             s = intOnly + "." + roundSmall;   
  133.         }   
  134.         return s;   
  135.     }   
  136.        
  137.     /**  
  138.      * 把传入的数转换为中文金额大写形式  
  139.      * @param flag int 标志位,1 表示转换整数部分,0 表示转换小数部分  
  140.      * @param s String 要转换的字符串  
  141.      * @return 转换好的带单位的中文金额大写形式  
  142.      */  
  143.     private String numFormat(int flag, String s) {   
  144.         int sLength = s.length();   
  145.         // 货币大写形式   
  146.         String bigLetter[] = {"零""壹""贰""叁""肆""伍""陆""柒""捌""玖"};   
  147.         // 货币单位   
  148.         String unit[] = {"元""拾""佰""仟""万",    
  149.                 // 拾万位到仟万位   
  150.                 "拾""佰""仟",   
  151.                 // 亿位到万亿位   
  152.                 "亿""拾""佰""仟""万"};   
  153.         String small[] = {"分""角"};   
  154.         // 用来存放转换后的新字符串   
  155.         String newS = "";   
  156.         // 逐位替换为中文大写形式   
  157.         for(int i = 0; i < sLength; i ++) {   
  158.             if(flag == 1) {   
  159.                 // 转换整数部分为中文大写形式(带单位)   
  160.                 newS = newS + bigLetter[s.charAt(i) – 48] + unit[sLength – i – 1];   
  161.             } else if(flag == 2) {   
  162.                 // 转换小数部分(带单位)   
  163.                 newS = newS + bigLetter[s.charAt(i) – 48] + small[sLength – i – 1];   
  164.             }   
  165.         }   
  166.         return newS;   
  167.     }   
  168.        
  169.     /**  
  170.      * 把已经转换好的中文金额大写形式加以改进,清理这个字  
  171.      * 符串里面多余的零,让这个字符串变得更加可观  
  172.      * 注:传入的这个数应该是经过 splitNum() 方法进行处理,这个字  
  173.      * 符串应该已经是用中文金额大写形式表示的  
  174.      * @param s String 已经转换好的字符串  
  175.      * @return 改进后的字符串  
  176.      */  
  177.     private String cleanZero(String s) {   
  178.         // 如果传入的是空串则继续返回空串   
  179.         if("".equals(s)) {   
  180.             return "";   
  181.         }   
  182.         // 如果用户开始输入了很多 0 去掉字符串前面多余的'零',使其看上去更符合习惯   
  183.         while(s.charAt(0) == '零') {   
  184.             // 将字符串中的 "零" 和它对应的单位去掉   
  185.             s = s.substring(2);   
  186.             // 如果用户当初输入的时候只输入了 0,则只返回一个 "零"   
  187.             if(s.length() == 0) {   
  188.                 return "零";   
  189.             }   
  190.         }   
  191.         // 字符串中存在多个'零'在一起的时候只读出一个'零',并省略多余的单位   
  192.         /* 由于本人对算法的研究太菜了,只能用4个正则表达式去转换了,各位大虾别介意哈… */  
  193.         String regex1[] = {"零仟""零佰""零拾"};   
  194.         String regex2[] = {"零亿""零万""零元"};   
  195.         String regex3[] = {"亿""万""元"};   
  196.         String regex4[] = {"零角""零分"};   
  197.         // 第一轮转换把 "零仟", 零佰","零拾"等字符串替换成一个"零"   
  198.         for(int i = 0; i < 3; i ++) {   
  199.             s = s.replaceAll(regex1"零");   
  200.         }   
  201.         // 第二轮转换考虑 "零亿","零万","零元"等情况   
  202.         // "亿","万","元"这些单位有些情况是不能省的,需要保留下来   
  203.         for(int i = 0; i < 3; i ++) {   
  204.             // 当第一轮转换过后有可能有很多个零叠在一起   
  205.             // 要把很多个重复的零变成一个零   
  206.             s = s.replaceAll("零零零""零");   
  207.             s = s.replaceAll("零零""零");   
  208.             s = s.replaceAll(regex2, regex3);   
  209.         }   
  210.         // 第三轮转换把"零角","零分"字符串省略   
  211.         for(int i = 0; i < 2; i ++) {   
  212.             s = s.replaceAll(regex4"");   
  213.         }   
  214.         // 当"万"到"亿"之间全部是"零"的时候,忽略"亿万"单位,只保留一个"亿"   
  215.         s = s.replaceAll("亿万""亿");   
  216.         return s;   
  217.     }   
  218. }  

 

 

实现程序示例二:

/*当金额为整数时,只表示整数部分,省略小数部分,并添加"整"字.

当金额中含有连续的0时,只需要一个"零"即可.

10的表示方式.例如110–壹佰一拾元整,10—一拾元整
*/
import java.io.*;
class chineseMoney{
   private String number[]={"","壹","贰","叁","肆","伍","陆","柒","捌","玖"};
   private String unit[]={"元","拾","佰","仟","万","拾","佰","仟","亿","拾","佰"};
   private String small[]={"角","分"};
   private String strNumber,strUnit,strAll;

   private String onlyInt(int intInt)
   {
       String strInt;
       strInt=String.valueOf(intInt);
       strNumber="";strUnit="";strAll="";
       int l=strInt.length ();
       int j,k,zeorCount;
       zeorCount=0;
       for (k=0;k<l;k++)
       {
           String strTemp=strInt.substring(k,k+1);
           int intTemp=Integer.parseInt(strTemp);
           strNumber=number[intTemp];
           j=l-1-k;
           strUnit=unit[j];
           if (intTemp==0)
           {
               if (zeorCount==0)
               {
                   strUnit=strUnit.replace('拾','零');
                   strUnit=strUnit.replace('佰','零');
                   strUnit=strUnit.replace('仟','零');
                   strUnit=strUnit.replace('万','零');
               }
               else
               {
                   strUnit=strUnit.replaceAll("拾","");
                   strUnit=strUnit.replaceAll("佰","");
                   strUnit=strUnit.replaceAll("仟","");
                   strUnit=strUnit.replaceAll("万","");
               }
               zeorCount++;
           }
           strAll+=strNumber+strUnit;
       }
       return strAll;

   }

   private String onlySmall(int intSmall)
   {

       strNumber="";strUnit="";strAll="";
       String strSmall,strTemp;
       strSmall=String.valueOf(intSmall);
       int i;
       if (intSmall>=10)
       {
           for (i=0;i<strSmall.length();i++)
           {
               strTemp=String.valueOf(intSmall).substring(i,i+1);
               if (Integer.parseInt(strTemp)!=0)
               {
                   strNumber=number[Integer.parseInt(strTemp)];
                   strUnit=small;
                   strAll+=strNumber+strUnit;
               }
           }
       }
       else
       {
           if (intSmall!=0)
           {
               strNumber=number[intSmall];
               strUnit=small[1];
               strAll+=strNumber+strUnit;
           }
       }

       return strAll;
   }

   public String getChineseMoney(double number)
   {
       //四舍五入
       number=(number*100+0.5)/100;

       String strAll,strChineseInt,strChineseSmall,strZheng;;
       int intInt,intSmall;
       strChineseInt="";strChineseSmall="";strZheng="";

       //整数部分
       intInt=(int)( number*100/100);
       if (intInt!=0)
       {
           strChineseInt=onlyInt(intInt);
       }
       //小数部分
       double temp=(number-intInt)*100*100/100;
       //对小数部分四舍五入
       intSmall=(int)(temp*100+0.5)/100;
       if (intSmall!=0)
       {
           strChineseSmall=onlySmall(intSmall);
       }
       else
       {
           strZheng="整";
       }
       strAll=strChineseInt+strChineseSmall+strZheng;
       return strAll;
   }
   public static void main(String args[]) throws IOException
   {
       chineseMoney cm=new chineseMoney();
       double money;
       String strMoney,strChineseMoney;
       strMoney="";
       //读取
       System.out.println("输入货币(四舍五入):");
       BufferedReader cin = new BufferedReader(new InputStreamReader( System.in));
       strMoney = cin.readLine();
       money=Double.parseDouble(strMoney);
       strChineseMoney=cm.getChineseMoney(money);
       System.out.println(strChineseMoney);
   }
}

点赞 (0)

发表评论

电子邮件地址不会被公开。 必填项已用*标注