遍个程序，将浮点数转成人民币读法字符串

Question

像200002.033506就是贰十万零贰元零角叁分 

Answer 1

给你贴个类似的将一个键盘输入的数字转化成中文输出
(例如:输入:1234567     输出:一百二拾三万四千五百六拾七)
用java语言实现,,请编一段程序实现!
 public class Reader {
  private String strNum;
  private String strNumChFormat;
  private String strNumTemp;
  private int intNumLen;
  private String strBegin;
  public Reader(String strNum) {
    this.strNum = strNum;
  }
  public boolean check(String strNum) {
    boolean valid = false;
    
    if (strNum.substring(0,1).equals("0")){
     this.strNum = strNum.substring(1);
    }
    try {
      new Double(strNum);
      valid = true;
    }
    catch (NumberFormatException ex) {
      System.out.println("Bad number format!");
    }
    return valid;
  }
  public void init() {
    strNumChFormat = "";
    intNumLen = strNum.length();
    strNumTemp = strNum;
    strNumTemp = strNumTemp.replace('1', '一');
    strNumTemp = strNumTemp.replace('2', '二');
    strNumTemp = strNumTemp.replace('3', '三');
    strNumTemp = strNumTemp.replace('4', '四');
    strNumTemp = strNumTemp.replace('5', '五');
    strNumTemp = strNumTemp.replace('6', '六');
    strNumTemp = strNumTemp.replace('7', '七');
    strNumTemp = strNumTemp.replace('8', '八');
    strNumTemp = strNumTemp.replace('9', '九');
    strNumTemp = strNumTemp.replace('0', '零');
    strNumTemp = strNumTemp.replace('.', '点');
    strBegin = strNumTemp.substring(0, 1);
  }
  public String readNum() {
    if (check(strNum)) {
      init();
      try {
        for (int i = 1, j = 1, k = 1; i < intNumLen; i++) {
          if (strNumTemp.charAt(intNumLen - 1) == '零' && i == 1) {
            strNumChFormat = "位";
          }
          else if (strNumTemp.charAt(intNumLen - i) == '零' && j == 1) {
            strNumChFormat = "位" + strNumChFormat;
          }
          else if (strNumTemp.charAt(intNumLen - i) == '点') {
            j = 1;
            k = 1;
            strNumChFormat = strNumTemp.charAt(intNumLen - i) + strNumChFormat;
            continue;
          }
          else {
            strNumChFormat = strNumTemp.charAt(intNumLen - i) + strNumChFormat;
          }
          if (strNumTemp.charAt(intNumLen - i - 1) != '位' &&
              strNumTemp.charAt(intNumLen - i - 1) != '零') {
            if (j == 1 && i < intNumLen) {
              strNumChFormat = '拾' + strNumChFormat;
            }
            else if (j == 2 && i < intNumLen) {
              strNumChFormat = '百' + strNumChFormat;
            }
            else if (j == 3 && i < intNumLen) {
              strNumChFormat = '千' + strNumChFormat;
            }
          }
          if (j == 4 && i < intNumLen) {
            j = 0;
          }
          if (k == 4 && i < intNumLen) {
            strNumChFormat = '万' + strNumChFormat;
          }
          else if (k == 8 && i < intNumLen) {
            k = 0;
            strNumChFormat = '亿' + strNumChFormat;
          }
          j++;
          k++;
        }
        while (strNumChFormat.indexOf("位") != -1) {
          strNumChFormat = strNumChFormat.replaceAll("位", " ");
        }
        if (strNumChFormat.substring(0, 2) == "一拾") {
          strNumChFormat = strNumChFormat.substring(1, strNumChFormat.length());
        }
        if (strNumChFormat.indexOf("点") >= 0) {
          String rebegin = strNumChFormat.substring(0,
              strNumChFormat.indexOf("点"));
          String relast = strNumChFormat.substring(strNumChFormat.indexOf("点"),
              strNumChFormat.length());
          for (int i = 1; i <= relast.length(); i++) {
            relast = relast.replaceAll("拾", "");
            relast = relast.replaceAll("百", "");
            relast = relast.replaceAll("千", "");
            relast = relast.replaceAll("万", "");
            relast = relast.replaceAll("亿", "");
          }
          strNumChFormat = rebegin + relast;
        }
      }
      catch (ArrayIndexOutOfBoundsException ex) {
        ex.printStackTrace();
      }
      catch (Exception ex) {
        ex.printStackTrace();
      }
      int off = strNumChFormat.indexOf("点");
      strNumChFormat = strBegin + strNumChFormat.substring(0);
    }
    else {
      strNumChFormat = "";
    }
    return strNumChFormat;
  }
  public static void main(String args[]) {
    try {
      String number = args[0].toString();
      System.out.println("The number is: " + number);
      Reader reader = new Reader(number);
      System.out.println("Output String: " + reader.readNum());
    }
    catch (Exception ex) {
      System.out.println("Please input like that: javac Reader <number>");
    }
  }
} 

Answer 2

http://user.qzone.qq.com/1037849661/blog/1249040740
我空间里的，应该是楼主需要的

Answer 3

import java.util.*;   
  
public class Num2Rmb   
{   
    private String[] hanArr= {"零" , "壹" , "贰" , "叁" , "肆" ,    
        "伍" , "陆" , "柒" , "捌" , "玖"};   
    private String[] unitArr = {"十", "百", "千"};   
  
    /**  
     * 把一个浮点数分解成整数部分和小数部分字符串  
     * @param num 需要被分解的浮点数  
     * @return 分解出来的整数部分和小数部分构成的数组。第一个数组元素是整数部分，第二个数组元素是小数部分。  
     */  
    private String[] divide(double num)   
    {   
        //将一个浮点数强制类型转换为long，即得到它的整数部分。   
        long zheng = (long)num;   
        //浮点数减去整数部分，得到小数部分，小数部分乘以100后再取整得到2位小数。   
        //Math类的round方法，返回与参数最接近(经四舍五入后)的整数。   
        long xiao = Math.round((num - zheng) * 100);   
        //下面用了2种方法把整数转换为字符串。   
        //return一个匿名数组。   
        //String类的valueOf(int i)方法,返回整数参数的字符串表达式。   
        return new String[]{zheng + ","+ String.valueOf(xiao)};                        
    }   
  
    /**  
     * 把一个12位以内的数字字符串变成汉字字符串  
     * @param numStr 需要被转换的数字字符串  
     * @return 数字字符串被转换成的汉字字符串。  
     */  
       
    private String toHanStr(String numStr)   
    {              
        int strLen = numStr.length();   
        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 = "";   
           
        //依次遍历数字字符串的每一节   
        for (int i = 0 ; i < partNum ; i ++ )   
        {      
            //转换第一节   
            if (i == 0)    
            {      
                //通过调用String类的substring方法来返回子串 [beginIndex, endIndex)，   
                //即：包括起始索引，不包括结束索引。   
                String firstPart = numStr.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];   
                   }   
                   //剩下的就是hanArr和unitArr都不需要读出来的情况   
               }     
            }   
            //转换第二节   
            else if (i == 1)   
            {      
                String secondPart = numStr.substring(firstPartLen, (firstPartLen + 4));   
                int secPartLen = secondPart.length();                  
                for (int k = 0 ; k < secPartLen ; k ++ )   
               {       
                   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];   
                   }   
                   else if (k == 2 && num == 0 && secondPart.charAt(1) - 48 == 0    
                            && secondPart.charAt(secPartLen - 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.substring((firstPartLen + 4), strLen);   
                int thirdPartLen = thirdPart.length();   
                for (i = 0 ; i < thirdPartLen ; i ++ )   
               {       
                   int num = thirdPart.charAt(i) - 48;                   
                   if (i != thirdPartLen-1 && num != 0)   
                   {   
                       resultThird += hanArr[num] + unitArr[thirdPartLen - 2 - i];            
                   }    
                   else if (i == thirdPartLen - 1 && num != 0)   
                   {   
                       resultThird += hanArr[num];   
                   }   
                   else if (i == 2 && num == 0 && thirdPart.charAt(1) - 48 == 0    
                            && thirdPart.charAt(thirdPartLen - 1) - 48 != 0)   
                   {   
                       resultThird += hanArr[num];   
                   }   
               }     
            }   
  
        }   
        String result = "";   
        if (partNum == 1)   
        {     
            //如果数字仅为0   
            if (resultFirst == "")   
            {   
                result = hanArr[0] + "元";   
            }   
            else  
            {   
                result = resultFirst + "元";   
            }   
        }   
        else if (partNum == 2)   
        {      
            //如果第二节全为0   
            if (Integer.parseInt(numStr.substring(firstPartLen, (firstPartLen + 4))) == 0)   
            {   
                result = resultFirst + "万";   
            }   
            else  
            {   
                result = resultFirst + "万" + " " + resultSecond+ "元";   
            }              
        }   
        else if (partNum == 3)   
        {      
               
            result = resultFirst + "亿" + " " + resultSecond + "万" + " " + resultThird+ "元";   
            //如果第二节和第三节均全为0            
            if (Integer.parseInt(numStr.substring(firstPartLen, (firstPartLen + 4))) == 0    
                && Integer.parseInt(numStr.substring((firstPartLen + 4), strLen)) == 0)   
            {   
                result = resultFirst + "亿";   
            }              
        }      
        return result;         
    }   
      
    public static void main(String[] args)   
    {      
        //等号左边的Num2Rmb是nr的变量类型，右边的Num2Rmb是构造器名   
        Num2Rmb nr = new Num2Rmb();   
        //测试把一个浮点数236711125.123分解成整数部分和小数部分   
        System.out.println(Arrays.toString(nr.divide(236711125.123)));   
        //测试把一个12位以内的数字字符串变成汉字字符串   
        System.out.println(nr.toHanStr("123456789123"));   
    }   
}  

Answer 4

我的blog里有
http://blog.csdn.net/billfranck/archive/2009/08/21/4470898.aspx