将浮点数转换成人民币读法字符串（整数部分在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)   
            {      
                 //通过调用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();
        
    }   
}