将浮点数转换成人民币读法字符串（整数部分在12位以内）

import java.util.Arrays;  

import java.util.Scanner;

public class Num2Rmb   

{   

    private  String[] hanArr= {"零" , "壹" , "贰" , "叁" , "肆" ,    

        "伍" , "陆" , "柒" , "捌" , "玖"};   

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

   

    /**  

     * 把一个浮点数分解成整数部分和小数部分字符串  

     * @param num 需要被分解的浮点数  

     * @return 分解出来的整数部分和小数部分构成的数组。第一个数组元素是整数部分，第二个数组元素是小数部分。  

     */  

    private static String[] divide(double num)   

    {   

        //将一个浮点数强制类型转换为long，即得到它的整数部分。   

        long zheng = (long)num;   

        //浮点数减去整数部分，得到小数部分，小数部分乘以100后再取整得到2位小数。   

        //Math类的round方法，返回与参数最接近(经四舍五入后)的整数。   
        long xiao = Math.round((num - zheng) * 100);  

        String xiaoStr;      

        if (xiao < 10 ){

            xiaoStr = 0 + "" + xiao   ;

       }else{

        //String类的valueOf(int i)方法,返回整数参数的字符串表达式。

           xiaoStr = String.valueOf(xiao);

       }

        //下面用了2种方法把整数转换为字符串。   

        //return一个numString数组。   

        String [] numString = {zheng +"",xiaoStr};

        return numString;                      

    }   

   

    /**  

     * 把一个12位以内的数字字符串变成汉字字符串  

     * @param numStr 需要被转换的数字字符串数组 

     * @return 数字字符串被转换成的汉字字符串。  

     */  

        

    private String toHanStr(String[]  numStr)   

    {              

        int strLen = numStr[0].length();         //获得整数部分的字符串的位数

        if(strLen > 12){                                      //如果字符串大于12位，就返回一个匿名的字符串

            return "您输入的浮点数，其整数部分的位数超过了限定的12位，请重新输入";

        }else{

        int yu = strLen % 4;   

        //partNum表示该数字字符串可划分成的节数（每4位为一节）。   

        //如余数等于0，则将strLen/4赋值给partNum；否则将strLen/4 + 1赋值给partNum。   

        int partNum = yu == 0 ? strLen/4 : strLen/4 + 1;   

        //firstPartLen表示第一节的长度   

        int firstPartLen = strLen - (partNum - 1)*4;   

        String resultFirst = "";   

        String resultSecond = "";   

        String resultThird = "";  

        String resultFourth = "";

            

        //依次遍历数字字符串的每一节   

        for (int i = 0 ; i < partNum ; i ++ )   

        {      

            //转换第一节   

            if (i == 0)    

            {      

                //通过调用String类的substring方法来返回子串 [beginIndex, endIndex)，   

                //即：包括起始索引，不包括结束索引。   

                String firstPart = numStr[0].substring(0, firstPartLen);   

                //依次遍历第一节中的每一位数字   

                for (int j = 0 ; j < firstPartLen ; j ++ )   

               {                          

                   //String类的charAt(int index)，返回指定索引处的字符串值。   

                   //把char型数字转换成的int型数字，因为它们的ASCII码值恰好相差48;            

                   //因此把char型数字减去48得到int型数字，例如'4'被转换成4。   

                   int num = firstPart.charAt(j) - 48;   

                   //如果不是最后一位数字，而且数字不是零，则需要添加单位（十、百、千）   

                   if (j != firstPartLen-1 && num != 0)   

                   {   

                       resultFirst += hanArr[num] + unitArr[firstPartLen - 2 - j];            

                   }               

                   //如果是最后一位数字，而且数字不是零，则不要添加单位   

                   else if (j == firstPartLen - 1 && num != 0)    

                   {   

                       resultFirst += hanArr[num];   

                   }   

                   //如果这一节的中间两个数字为0, 且第一位和最后一位数字不为0, 则需要读出一个零   

                   else if (j == 2 && num == 0 && firstPart.charAt(1) - 48 == 0  

                            && firstPart.charAt(0) - 48 != 0  

                            && firstPart.charAt(firstPartLen - 1) - 48 != 0)   

                   {   

                       resultFirst += hanArr[num];   

                   }

                   //如果第三位为零，且第二位不为零，第四位不为零，则需要读一个零

                   else if(j == 2 && num == 0 && firstPart.charAt(1) - 48 != 0

                           && firstPart.charAt(firstPartLen - 1) - 48 != 0){

                       resultFirst += hanArr[num];

                   }

                   //如果第二位为零，且第一位和第三位不为零，则需要读一个零

                   else if(j == 1 && num == 0 && firstPart.charAt(0) - 48 != 0

                           && firstPart.charAt(2) - 48 != 0){

                       resultFirst += hanArr[num];

                   }

                   //剩下的就是hanArr和unitArr都不需要读出来的情况   

               }     

            }   

            //转换第二节   

            else if (i == 1)   

            {      

   
4000
              //通过调用String类的substring方法来返回子串 [beginIndex, endIndex)，   

                //即：包括起始索引，不包括结束索引。   

                String secondPart = numStr[0].substring(firstPartLen, (firstPartLen + 4));

                //第二节的长度                

                int secPartLen = secondPart.length();

                //依次遍历第二节的每一位数字

                for (int k = 0 ; k < secPartLen ; k ++ )   

               {     

                    //String类的charAt(int index)，返回指定索引处的字符串值。(类似于数组)。   

                    //把char型数字转换成的int型数字，因为它们的ASCII码值恰好相差48;            

                    //因此把char型数字减去48得到int型数字，例如'4'被转换成4。   

                   int num = secondPart.charAt(k) - 48;  

                   //如果不是最后一位数字，而且数字不是零，则需要添加单位（十、百、千）   

                   if (k != secPartLen-1 && num != 0)                         

                   {   

                       resultSecond += hanArr[num] + unitArr[secPartLen - 2 - k];            

                   }    

                  //如果是最后一位数字，而且数字不是零，则不要添加单位   

                   else if (k == secPartLen - 1 && num != 0)                 

                   {   

                       resultSecond += hanArr[num];   

                   }   

                   //如果这一节的中间两个数字为0, 且第一位和最后一位数字不为0, 则需要读出一个零   

                   else if (k == 2 && num == 0 && secondPart.charAt(1) - 48 == 0    

                            && secondPart.charAt(secPartLen - 1) - 48 != 0)   

                   {   

                       resultSecond += hanArr[num];   

                   }   

                   //如果第三位为零，且第二位不为零，第四位不为零，则需要读一个零

                   else if(k == 2 && num == 0 && secondPart.charAt(1) - 48 != 0

                           && secondPart.charAt(secPartLen - 1) - 48 != 0){

                       resultSecond += hanArr[num];

                   }

                   //如果第二位为零，且第一位和第三位不为零，则需要读一个零

                   else if(k == 1 && num == 0 && secondPart.charAt(0) - 48 != 0

                           && secondPart.charAt(2) - 48 != 0){

                       resultSecond += hanArr[num];

                   }

                   //如果第一位为0，第二位为零，第三位不为零，则需读一个零

                   else if(k == 0 && num == 0 && secondPart.charAt(1) - 48 == 0

                           && secondPart.charAt(2) - 48 != 0){

                       resultSecond += hanArr[num];

                   }

                   //如果第一位为零，第二位不为零则需读一个零

                   else if(k == 0 && num == 0 && secondPart.charAt(1) - 48 != 0){

                       resultSecond += hanArr[num];

                   }

               }                  

                //如果四位数字全是0, 且第二节不是最后一节, 则只需读出一个零。   

                //Integer类的parseInt(String s)方法：将整数字符串参数解析成一个带符号的十进制整数。   

                if (Integer.parseInt(secondPart) == 0 && partNum == 3)   

               {                       

                    resultSecond = hanArr[0];   

               }                  

            }   

            //转换第三节   

            else if (i == 2)   

            {      

                String thirdPart = numStr[0].substring((firstPartLen + 4), strLen);   

                int thirdPartLen = thirdPart.length();   

                for (i = 0 ; i < thirdPartLen ; i ++ )   

               {       

                   int num = thirdPart.charAt(i) - 48;     

                   //如果不是这一节的最后一位且数字不为0，则需要加单位

                   if (i != thirdPartLen-1 && num != 0)   

                   {   

                       resultThird += hanArr[num] + unitArr[thirdPartLen - 2 - i];            

                   }  

                   //如果是这一节的最后一位且数字不为0，则不需要加单位

                   else if (i == thirdPartLen - 1 && num != 0)   

                   {   

                       resultThird += hanArr[num];   

                   }

                   //如果这一节中间两个为0，且第一位和最后一位不为0，则需要读一个零

                   else if (i == 2 && num == 0 && thirdPart.charAt(1) - 48 == 0

                           && thirdPart.charAt(0) - 48 != 0  

                           && thirdPart.charAt(thirdPartLen - 1) - 48 != 0)   

                   {   

                       resultThird += hanArr[num];  

                   }  

                 //如果第三位为零，且第二位不为零，第四位不为零，则需要读一个零

                   else if(i == 2 && num == 0 && thirdPart.charAt(1) - 48 != 0

                           && thirdPart.charAt(thirdPartLen - 1) - 48 != 0){

                       resultThird += hanArr[num];

                   }

                   //如果第二位为零，且第一位和第三位不为零，则需要读一个零

                   else if(i == 1 && num == 0 && thirdPart.charAt(0) - 48 != 0

                           && thirdPart.charAt(2) - 48 != 0){

                       resultThird += hanArr[num];

                   }

                   //如果第一位为0，第二位为零，第三位不为零，则需读一个零

                   else if(i == 0 && num == 0 && thirdPart.charAt(1) - 48 == 0

                           && thirdPart.charAt(2) - 48 != 0){

                       resultThird += hanArr[num];

                   }

                   //如果第一位为零，第二位不为零则需读一个零

                   else if(i == 0 && num == 0 && thirdPart.charAt(1) - 48 != 0){

                       resultThird += hanArr[num];

                   }

               }     

            }   

   

        }

        //遍历小数部分

     for(int i = 0;i < numStr[1].length();i++){

            int num = numStr[1].charAt(i) - 48;

            //如果数字不为零，则需要加单位

            if(num != 0){

                resultFourth += hanArr[num] + unitArr[i + 3 ];

            }            

            //如果小数部分第一位为零，第二位不为零，则需要读一个零

            else if (i == 0 && num == 0 && numStr[1].charAt(1) - 48 !=0 ){

                resultFourth  += hanArr[num];

            }

        }

    

        String result = "";   

        if (partNum == 1)   

        {     

            //如果数字仅为0   

            if (resultFirst == "")   

            {   

                result = hanArr[0] + "元" + resultFourth ;   

            }   

            else  

            {   

                result = resultFirst + "元" + resultFourth ;   

            }   

        }   

        else if (partNum == 2)   

        {      

            //如果第二节全为0   

            if (Integer.parseInt(numStr[0].substring(firstPartLen, (firstPartLen + 4))) == 0)   

            {   

                result = resultFirst+"万元" + resultFourth ;   

            }   

            else  

            {   

                result = resultFirst + "万" + resultSecond+ "元" + resultFourth ;

            }              

        }   

        else if (partNum == 3)   

        {      

                

            result = resultFirst + "亿" + resultSecond + "万" +resultThird+ "元" +  resultFourth;   

            //如果第二节和第三节均全为0            

            if (Integer.parseInt(numStr[0].substring(firstPartLen, (firstPartLen + 4))) == 0    

                && Integer.parseInt(numStr[0].substring((firstPartLen + 4), strLen)) == 0)   

            {

                result = resultFirst + "亿元" + resultFourth ;   

            }  

            //如果第二节全为0且第三节不为0

            else if (Integer.parseInt(numStr[0].substring(firstPartLen, (firstPartLen + 4))) == 0    

                    && Integer.parseInt(numStr[0].substring((firstPartLen + 4), strLen)) != 0){

                 result = resultFirst + "亿" + resultThird + "元" + resultFourth;    

            }

        }

        return result;         

    }   

  }  

    public static void main(String[] args)   

    {      

        //等号左边的Num2Rmb是nr的变量类型，右边的Num2Rmb是构造器名   

        Num2Rmb nr = new Num2Rmb();

        //通过Scanner类来实现交互式输入与输出

        Scanner input = new Scanner(System.in);

        //提示用户输入想要读成人民币的浮点数

        System.out.println("请输入要读成人民币的浮点数：");

        //请输入的浮点数保存在变量num里面，保存为浮点数

        double num = input.nextDouble();

        //测试把一个浮点数num分解成整数部分和小数部分   

        System.out.println(Arrays.toString(Num2Rmb.divide(num)));

        //将divide方法返回来的字符数组，保存在字符数组numStr里

        String [] numStr = divide(num);

        //输出最终的人民币读法

        System.out.println(nr.toHanStr(numStr));

        //关闭input

        input.close();

        

    }   

}