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();
        
    }   
}