Java浮点数转人民币读法

  • 把【整数部分】的数字,由个位开始,4个数字分为一组,最高位没有数字就补0,并记录总共的数组个数,总共有3组,也就3*4的二维数组;
  • 对于每个数组统一处理,最后将最开头的“零去掉”,将“亿”、“万”“元”字前面的“零”去掉;
  • 当读取到0时,检查它的上一位是否为0,如果上一位是0,则不做处理,如果上一位不是0或者上一位不存在,均记下“零”;
  • 读取每个数字,转换为对应的大写汉字,并加上权重“仟、佰、拾”,根据读取的是第几个数组,后面添加相应的“亿”、“万”“元”;
  • 把【小数部分】做一维数组处理,仅保留两位小数,对应“角”和“分”,数字0不处理;

测试数字『120, 3005, 7600.89』,读作:壹佰贰拾亿叁仟零伍万柒仟陆佰元捌角玖分。


package theTest;
public class NumToRmb {

     private String[] hanArr={"零","壹","贰","叁","肆","伍","陆","柒","捌","玖"};

     private String[] unitArr={"仟","佰","拾"};

     /**
      * 把一个浮点数分解成整数部分和小数部分字符串
      * @param num 需要被分解的浮点数
      * @return 分解出来的整数部分和小数部分,第1个数组元素是整数部分,第2个数组元素是小数部分。
      */
     private String[] divide(double num){
           //将一个浮点数强制转换为long型,即得到它的整数部分
           long zheng=(long)num;

           //浮点数减去整数部分,得到小数部分,小数部分乘以100取整得到两位小数
           long xiao=Math.round((num-zheng)*100);

           //这里使用两种方法将整数转换为字符串
           return new String[]{String.valueOf(zheng),xiao+""};
     }
     /**
      * 将整数分成4个数字为一组的字符串处理,转化成大写数字再将它们连接起来,得到最终的人民币读法
      * @param num 需要被转化为大写数字的浮点数
      * @return 返回整个数字的人民币读法
      */
     private String conHanStr(double num){

           //存储整数结果、小数结果
           String resZheng="";
           String resXiao="";

           //存储最终结果
           String result="";

           //分别存储整数部分和小数部分字符串
           String zhengStr=divide(num)[0];
           String xiaoStr=divide(num)[1];

           /*小数部分的处理*/
           if(xiaoStr.length()==1){
                xiaoStr="0"+xiaoStr;
           }

           resXiao=xiao2Han(xiaoStr);

           /*整数部分的处理*/
           //记录字符串个数,是第几个数组
           int countArr=0;
           String tempStr="";

           //记录位数
           int countNum=0;

           for(int i=zhengStr.length()-1;i>=0;i--){
                countNum++;
                tempStr=zhengStr.charAt(i)+tempStr;

                if(i-1<0){
                     //i已经是最后一个数字,不够的位,补0
                     while(tempStr.length()<4){
                           tempStr="0"+tempStr;
                     }
                     countArr++;
                     resZheng=zheng2Han(countArr,tempStr)+" "+resZheng;
                }else{
                     if(countNum==4){
                           countArr++;
                          resZheng=zheng2Han(countArr,tempStr)+" "+resZheng;
                           countNum=0;
                           tempStr="";
                     }
                }
           }

           //去掉开头的零
           if(resZheng.charAt(0)==‘零‘){
                resZheng=resZheng.substring(1,resZheng.length());
           }

           /*整数和小数的连接*/
           //表示整数部分为0
           if(resZheng.charAt(0)==‘元‘){
                resZheng="零"+resZheng;
           }

           result=resZheng+resXiao;

           return result;
     }

     /**
      * 每个4位的整数组转化为大写的数字
      * @param count 记录是第几个数组(1-3)
      * @param str 需要被转换的数组
      * @return 返回该数组人民币读法
      */
     private String zheng2Han(int count,String str){

           String result="";
           for(int j=0;j<4;j++){
                int tempNum=str.charAt(j)-48;
                if(tempNum!=0){
                     if(j!=3){
                           result+=hanArr[tempNum]+unitArr[j];
                     }else{
                           result+=hanArr[tempNum];
                     }
                }else{
                     if((j-1<0)||(str.charAt(j-1)-48!=0)){
                           result+=hanArr[tempNum];
                     }
                }
           }

           //去掉末尾的零
           if(result.charAt(result.length()-1)==‘零‘){
                result=result.substring(0, result.length()-1);
           }

           //去零之后添加“亿、万、元、角、分”。
           switch(count){
           case 1:
                result+="元";
                break;
           case 2:
                result+="万";
                break;
           case 3:
                result+="亿";
                break;
           default:
                System.out.println("仅支持不大于9999,9999,9999.99的数字!");
                return "";
           }
           return result;
     }

     /**
      * 小数转化为大写的数字
      * @param str 需要被转换的数组
      * @return 返回该小数人民币读法
      */
     private String xiao2Han(String str){
           String result="";
           if(!str.equals("00")){
                for(int i=0;i<2;i++){
                     int tempNum=str.charAt(i)-48;
                     if((tempNum!=0)&&(i==0)){
                           result+=hanArr[tempNum]+"角";
                     }
                     if((tempNum!=0)&&(i==1)){
                           result+=hanArr[tempNum]+"分";
                     }
                }
           }
           return result;
     }

     /**
      * 主函数
      * @param args
      */
     public static void main(String[] args) {
           NumToRmb nr=new NumToRmb();
          System.out.println(nr.conHanStr((double)12030060078.95));
     }
}

原文地址:https://www.cnblogs.com/dlcicc/p/8521356.html

时间: 2024-10-07 06:20:00

Java浮点数转人民币读法的相关文章

java实战1——浮点数转人民币读法

为了学习安卓,现在开始从C++角度来学习Java,现在看到了<疯狂java讲义>的第四章,里面有个字符串转人民币的例子,书上没做完,于是把其补充完善.其中最难的部分就是根据零在不同位置,具有不同行为.按照中文读法,有些零要读出,有些零不需要读出.下面将按照两部分进行讲解,首先举一个例子来说明思路,其次给出Java的源代码供参考,并且进行测试.这个问题主要利用字符串数组来解决.我们假定要转换的浮点数整数部分不超过12位. (1) 思路 1.1 分割整数和小数部分 对于一个浮点数,先来看个简单点,

java程序---将一个浮点数转换成人民币读法

代码如下: <span style="font-size:18px;">package test; import java.util.Scanner; //将输入的浮点型钱数,转成人民币读法 public class Num2Rmb { private static double num; private long zheng,xiao; private String[] hanArr={"零","壹","贰",&

千亿级别数字的人民币读法

</pre><pre name="code" class="java">package com.sungeo; /** * 人民币的读法是四位一节: x仟x百x拾 x (亿) x仟x百x拾 x (万) x仟x百x拾 x * @author Administrator */ public class NumToRmb { private String[] hanArr=new String[]{"零","壹&quo

数字转人民币读法

han_list=["零","壹","贰","叁","肆","伍","陆","柒","捌","玖"] unit_list=["拾","佰","仟"] #把整数部分和小数部分转化为字符串,并存入元组作为返回值 def devide(num): inte

js,java,浮点数运算错误及应对方法

js,java,浮点数运算错误及应对方法 一,浮点数为什么会有运算错误 IEEE 754 标准规定了计算机程序设计环境中的二进制和十进制的浮点数自述的交换.算术格式以及方法. 现有存储介质都是2进制.2进制的进制基数是2,那么一个数字只要被因素包含大于2的质数的数除,都会产生无限循环小数.无限循环小数和无理数都无法,和非无限循环的有理数一起用同一种方式存储到存储介质上的同时还保持计算的兼容性. 对于无限循环小数,可以设计一种格式存储到介质上,但是同时又要和非无限循环的有理数能够计算,效率应该会变

JAVA 浮点数转化为百分数,分离整数和小数部分

JAVA 浮点数转化为百分数 public class DoubleToPercentformat { /** * 将double类型数据转换为百分比格式,并保留小数点前IntegerDigits位和小数点后FractionDigits位 * @param d * @param IntegerDigits * @param FractionDigits * @return */ public static String getPercentFormat(double d,int IntegerD

Java 浮点数精度丢失

Java 浮点数精度丢失 问题引入 昨天帮室友写一个模拟发红包抢红包的程序时,对金额统一使用的 double 来建模,结果发现在实际运行时程序的结果在数值上总是有细微的误差,程序运行的截图: 输入依次为:红包个数,抢红包的人数,选择固定金额红包还是随机金额红包,每个红包的金额(此例只有一个红包). 注意到程序最后的结果是有问题的,我们只有一个金额为 10 的红包,一个人去抢,所以正确结果应该为这个人抢到了 10 RMB. 为了使问题更加明显,我们测试一个更加简单的例子: public class

Java浮点数相等性的判断

Java浮点数相等性的判断 问题描述如下: 给定两个变量double a.double b,它们对应的装箱类型变量分别是Double x.Double y,问: 是否存在一组a.b.x.y,满足 a==b && !x.equals(y) ? 是否存在一组a.b.x.y,满足 a!=b && x.equals(y) ? 乍看之下似乎是不可能的,实际上确实存在这样的值,参考以下代码 public static void main() { double a = 0.0; doub

Java 浮点数 float或double类型的表示范围和精度

隐约记得,浮点数判断大小好像有陷阱,因为底层的二进制数不能精确表示所有的小数.有时候会产生让人觉得莫名其妙的事情. 如在java中, 0.99999999f==1f //true 0.9f==1f //false 要明白这些,首先要搞清楚float和double在内存结构 1.内存结构 float和double的范围是由指数的位数来决定的. float的指数位有8位,而double的指数位有11位,分布如下: float: 1bit(符号位) 8bits(指数位) 23bits(尾数位) dou