一个程序的编写

    public static String numberToChinese(double d) {
        DecimalFormat decimalformat = new DecimalFormat("############0.00");
        String s = decimalformat.format(d);
        int i = s.indexOf(".");
        if(s.substring(i).compareTo(".00") == 0)
            s = s.substring(0, i);
        String s1 = "";
        String as[] = new String[4];
        String as1[] = new String[4];
        String as2[] = new String[2];
        String s2 = "";
        String s4 = "";
        String s6 = "";
        int j = 0;
        int k = 0;
        boolean flag = false;
        as[0] = "";
        as[1] = "\u62FE";
        as[2] = "\u4F70";
        as[3] = "\u4EDF";
        as1[0] = "";
        as1[1] = "\u4E07";
        as1[2] = "\u4EBF";
        as1[3] = "\u4E07";
        as2[0] = "\u5206";
        as2[1] = "\u89D2";
        if(s.compareTo("0") == 0 || s.compareTo("0.0") == 0 || s.compareTo("0.00") == 0) {
            s6 = "\u96F6\u5143\u6574";
            return s6;
        }
        if(s.indexOf(".") > 0)
            s1 = s.substring(0, s.indexOf("."));
        else
            s1 = s;
        j = s1.length() % 4 == 0 ? s1.length() / 4 : s1.length() / 4 + 1;
        for(int i1 = j; i1 >= 1; i1--) {
            int l;
            if(i1 == j && s1.length() % 4 != 0)
                l = s1.length() % 4;
            else
                l = 4;
            String s3 = s1.substring(k, k + l);
            for(int j1 = 0; j1 < s3.length(); j1++)
                if(Integer.parseInt(s3.substring(j1, j1 + 1)) != 0)
                    switch(Integer.parseInt(s3.substring(j1, j1 + 1))) {
                        case 1:
                            s6 = s6 + "\u58F9" + as[s3.length() - j1 - 1];
                            break;

                        case 2:
                            s6 = s6 + "\u8D30" + as[s3.length() - j1 - 1];
                            break;

                        case 3:
                            s6 = s6 + "\u53C1" + as[s3.length() - j1 - 1];
                            break;

                        case 4:
                            s6 = s6 + "\u8086" + as[s3.length() - j1 - 1];
                            break;

                        case 5:
                            s6 = s6 + "\u4F0D" + as[s3.length() - j1 - 1];
                            break;

                        case 6:
                            s6 = s6 + "\u9646" + as[s3.length() - j1 - 1];
                            break;

                        case 7:
                            s6 = s6 + "\u67D2" + as[s3.length() - j1 - 1];
                            break;

                        case 8:
                            s6 = s6 + "\u634C" + as[s3.length() - j1 - 1];
                            break;

                        case 9:
                            s6 = s6 + "\u7396" + as[s3.length() - j1 - 1];
                            break;
                    } else
                        if(j1 + 1 < s3.length() && s3.charAt(j1 + 1) != '0')
                            s6 = s6 + "\u96F6";

            k += l;
            if(i1 < j) {
                if(Integer.parseInt(s3.substring(s3.length() - 1, s3.length())) != 0 || Integer.parseInt(s3.substring(s3.length() - 2, s3.length() - 1)) != 0 || Integer.parseInt(s3.substring(s3.length() - 3, s3.length() - 2)) != 0 || Integer.parseInt(s3.substring(s3.length() - 4, s3.length() - 3)) != 0)
                    s6 = s6 + as1[i1 - 1];
            } else {
                s6 = s6 + as1[i1 - 1];
            }
        }

        if(s6.length() > 0)
            s6 = s6 + "\u5143";
        if(s.indexOf(".") > 0) {
            String s5 = s.substring(s.indexOf(".") + 1);
            for(int k1 = 0; k1 < 2; k1++)
                if(Integer.parseInt(s5.substring(k1, k1 + 1)) != 0)
                    switch(Integer.parseInt(s5.substring(k1, k1 + 1))) {
                        case 1: // ?0?7\001?0?7
                            s6 = s6 + "\u58F9" + as2[1 - k1];
                            break;

                        case 2: // ?0?7\002?0?7
                            s6 = s6 + "\u8D30" + as2[1 - k1];
                            break;

                        case 3: // ?0?7\003?0?7
                            s6 = s6 + "\u53C1" + as2[1 - k1];
                            break;

                        case 4: // ?0?7\004?0?7
                            s6 = s6 + "\u8086" + as2[1 - k1];
                            break;

                        case 5: // ?0?7\005?0?7
                            s6 = s6 + "\u4F0D" + as2[1 - k1];
                            break;

                        case 6: // ?0?7\006?0?7
                            s6 = s6 + "\u9646" + as2[1 - k1];
                            break;

                        case 7: // ?0?7\007?0?7
                            s6 = s6 + "\u67D2" + as2[1 - k1];
                            break;

                        case 8: // ?0?7\b?0?7
                            s6 = s6 + "\u634C" + as2[1 - k1];
                            break;

                        case 9: // ?0?7\t?0?7
                            s6 = s6 + "\u7396" + as2[1 - k1];
                            break;
                    } else
                        if(s6.length() > 0)
                            s6 = s6 + "\u96F6";

        } else {
            s6 = s6 + "\u6574";
        }
        if(s6.substring(s6.length() - 1).compareTo("\u96F6") == 0)
            s6 = s6.substring(0, s6.length() - 1);
        return s6;
    }

不是吧，这只是一道java的笔试题啊，这么长搞屁啊

用hashtable存基本的数字和汉字，例{"1","壹"}在用swtich case选一下就行了

应付考试的方法String testStr ="10034";testStr.replace('1', '一');
testStr.replace('2', '二');
testStr.replace('3', '三');
testStr.replace('4', '四');
testStr.replace('5', '五');
testStr.replace('6', '六');
testStr.replace('7', '七');
testStr.replace('8', '八');
testStr.replace('9', '九');
testStr.replace('0', '零');

String testStr ="10034"; testStr = testStr.replaceAll("1", "一");
testStr = testStr.replaceAll("2", "二");
testStr = testStr.replaceAll("3", "三");
testStr = testStr.replaceAll("4", "四");
testStr = testStr.replaceAll("5", "五");
testStr = testStr.replaceAll("6", "六");
testStr = testStr.replaceAll("7", "七");
testStr = testStr.replaceAll("8", "八");
testStr = testStr.replaceAll("9", "九");
testStr = testStr.replaceAll("0", "零"); System.out.println(testStr);

给个答案吧，最好是java的，c++蛮差

给你吧，记得给分啊
public class Change{

void fun(String str)
{
String str1="零壹贰叁肆伍陆柒捌玖";
String str2="千百十万千百十元角分";
double money=Double.parseDouble(str);
long temp;
long m[] =new long[10];
int i;
boolean flag=false;
int x=0;
int y=9;
money=money*100+0.5;
temp=(long)money;
m[0]=temp/1000000000;
m[1]=(temp%1000000000)/100000000;
m[2]=(temp%100000000)/10000000;
m[3]=(temp%10000000)/1000000;
m[4]=(temp%1000000)/100000;
m[5]=(temp%100000)/10000;
m[6]=(temp%10000)/1000;
m[7]=(temp%1000)/100;
m[8]=(temp%100)/10;
m[9]=temp%10;
for(i=0;i<10;i++)
{
if(m[i]!=0)
{
x=i;
break;
}
}
for(i=9;i>=0;i--)
{
if(m[i]!=0)
{
y=i;
break;
}
}
for(i=x;i<y+1;i++)
{
//System.out.print(m[i]);
if(m[i]==0)
{
if(flag==false)
{
System.out.print(""+str1.charAt((int)m[i]));
flag=true;
}

}
else
{

System.out.print(""+str1.charAt((int)m[i])+str2.charAt(i));
flag=false;
}
}
}
public static void main(String args[])
{
Change obj=new Change();
obj.fun(args[0]);
}}

又是人民币...import java.text.*;
public class ChineseCurrency{
public static void main(String[] args) {
double number = 100035.53;
System.out.println(toChineseCurrency(number));
}

public static String toChineseCurrency(Object o) {
if(o instanceof Number) {
String s = new DecimalFormat("#.00").format(o);
System.out.println(s);
s = s.replaceAll("\\.", "");
char[] digit = {'零', '壹', '贰', '叁', '肆',
'伍', '陆', '柒', '捌', '玖'};
String unit = "仟佰拾兆仟佰拾亿仟佰拾万仟佰拾元角分";
int l = unit.length();
StringBuilder sb = new StringBuilder(unit);
for(int i=s.length()-1; i>=0; i--)
sb = sb.insert(l-s.length()+i, digit[(s.charAt(i) - 0x30)]);
s = sb.substring(l-s.length(), l+s.length());
s = s.replaceAll("零[拾佰仟]", "零").
replaceAll("零{2,}", "零").
replaceAll("零([兆万元])", "$1").
replaceAll("零[角分]", "");
return s;
} else {
throw new NumberFormatException();
}
}
}

照楼主帖子的意思，也写了完整的一个，供大家参考import java.util.HashMap;public class NumberToChinese {

public static void main(String[] args)
{
StringBuffer numberToCn = new StringBuffer();

String number = "-2813040410.0787003560";

HashMap cnHash = getCNHash();

HashMap unitHash = getUnitHash();

String[] partOfNumber = null;

if(number.substring(0, 1).equals("-")) //判断数字是否为负数，并将数划分为小数、整数两部分
{
numberToCn.append("負");
partOfNumber = number.substring(1).split("\\.");
}
else
partOfNumber = number.substring(0).split("\\.");

if(partOfNumber.length == 1) //如果输入的数没有小数则只进行整数部分转化
{
    String str = PositiveChangeToCN(partOfNumber[0],cnHash,unitHash);
        numberToCn.append(str);
    }
else //如输入的数有小数，则先转化整数部分，再转换小数部分
{
String str = PositiveChangeToCN(partOfNumber[0],cnHash,unitHash); //处理整数部分
    numberToCn.append(str);     numberToCn.append("點"); str = DecimalChangeToCN(partOfNumber[1],cnHash); //处理小数部分
    numberToCn.append(str);
}

System.out.println("Number = " + number);
System.out.println("Chinese = " + numberToCn.toString());
}

/**
* 设置汉字中的数字表示名称
* @return
*/
public static HashMap getCNHash()
{
HashMap cnHash = new HashMap();
int count = 10;
String[] cnArray = {"零","壹","貳","叁","肆","伍","陸","柒","捌","玖","拾"};

for(int i = 0; i < count; i++)
{
cnHash.put(String.valueOf(i),cnArray[i]);
}
return cnHash;
}

/**
* 设置汉字中的数字单位名称
* @return
*/
public static HashMap getUnitHash()
{
HashMap unitHash = new HashMap();
int count = 5;
String[] unitArray = {"拾","佰","仟","萬","億","兆"};

for(int i = 2; i < count+2; i++)
{
unitHash.put(String.valueOf(i),unitArray[i-2]);
}
return unitHash;
}

/**
* 转化数字小数部分
* @param numberStr
* @param cnHash
* @return
*/
public static String DecimalChangeToCN(String numberStr,HashMap cnHash)
{
   StringBuffer cnStrBuffer = new StringBuffer();

   int zeroNumberAtLast = scanZeroAtLast(numberStr); //转化时除去输入时小数部分末尾存在的0

       //遍历数字，转换表示方式及单位
   for(int i = 0; i < numberStr.length() - zeroNumberAtLast; i++)
   {
   String aCnCode = (String)cnHash.get(numberStr.substring(i, i+1));  //转换数字表示名称
   cnStrBuffer.append(aCnCode);
   }
   return cnStrBuffer.toString();
}

/**
* 转化数字正数部分，按照每四位数作为一个单元进行转化
* @param numberStr
* @param cnHash
* @param unitHash
* @return
*/
private static String PositiveChangeToCN(String numberStr,HashMap cnHash,HashMap unitHash)
{
StringBuffer cnStrBuffer = new StringBuffer();

int changeUnit = 4; //每次转换的位数范围
int strLength = numberStr.length();
int tempLoopCount = strLength /changeUnit;

if(strLength % changeUnit > 0)
tempLoopCount++;

for (int loop = 1 ; loop <= tempLoopCount; loop++) //每四位数字为一个单位转换数字
{

int beginIndex = strLength - (changeUnit * loop);
int endIndex = beginIndex + changeUnit;

if(beginIndex < 0)
{
beginIndex = 0;
endIndex = strLength % changeUnit;
}

String tempStr = numberStr.substring(beginIndex,endIndex);
int zeroNumberAtLast = scanZeroAtLast(tempStr); //转化时除去输入时整数部分末尾存在的0

String aCnCode = new String();

//遍历数字，转换表示方式及单位
for(int i = 0; i < tempStr.length() - zeroNumberAtLast; i++)
{
String number = tempStr.substring(i, i+1);
    aCnCode += (String)cnHash.get(number);  //转换数字表示名称

            //根据数字所在数中的位置设置对应的单位
if(!number.equals("0"))
{
int position = tempStr.length() - i;
if(position > 1)
               aCnCode += (String)unitHash.get(String.valueOf(position)); //获取数字单位名称(拾、佰、仟)
}
}

if(loop > 1)
{
   aCnCode += (String)unitHash.get(String.valueOf(loop + 3)); //获取数字单位名称(萬、億、兆)
}

cnStrBuffer.insert(0, aCnCode); //合成转换结果
}

return cnStrBuffer.toString();
}

/**
* 返回正数部分末尾为0的个数
* @param numberStr
* @return
*/
public static int scanZeroAtLast(String numberStr)
{
int zeroNumberAtLast = 0;
int i = numberStr.length();

for(; i > 0; i--) //从数字字符串末尾开始遍历，获取由末尾开始连续的数字为0的个数
{
if(numberStr.substring(i-1,i).equals("0"))
zeroNumberAtLast++;
else
break;
}
return zeroNumberAtLast;
}
}

都是网上搜的！
我机器中有一个网页记录，给你转一下，绝对好用
  问题:         商业领域,开发票,支票等金钱相关项目通常要求转换成大写,诸如“壹拾圆陆角玖分”.编程过程中,一般的钱币都是double型.

  当前看到的方法:之所以写这个方法,因为看到的方法设计的不是很好,通常的做法就是逐个字符处理,通过冗长的switch...case结构判断,来决定当前是否应该输出某某汉字,总体来说,完成这件任务是简单的,但是代码和设计质量却不令人满意.


  设计方法如下:
  需要注意的问题:
          1.各个阿拉伯数字可以通过一个数组'壹','贰','叁'....表示.
          2.对于大于10000和大于100000000的数字,可能出现'万','亿'字样
          3.对于中间连续为0的数字,正确出现'零'的字样,但是有几种不同的情况需要处理
          4.对于某个段的数字全零的情况,例如,整个万段都是0的情况-100000101,中间的0如何出现
          5.角分的处理,如果不存在角分的话,应该出现'圆整'的字样
          6.整数部分不存在的情况,即只有角分,应该没有'圆'的字样
  设计框架:
          1.把数字转化成字符串处理,使用Java的时候,把一个double类型转化成一个字符串类型很简单,
          调用         String.valueOf(double_var)即可得到,但是有一个问题,当你的数字大于10个位的时候,
          也就是达亿的时候,他会转换成科学计数法的字串,解决方法就是把他转化成整形long.

          2.把数字分割成整数部分和小数部分分别处理,根据上面的方法,我们索性把double乘上100,
          取后两位为小数部分,前面的为整数部分,得到
          long   l   =   (long)(d*100);
          String   strVal   =   String.valueOf(l);
          String   head   =   strVal.substring(0,strVal.length()-2);                   //整数部分
          String   end   =   strVal.substring(strVal.length()-2);                             //小数部分

          3.我们应该把钱数分成段,每四个一段,实际上得到的是一个二维数组,如下:
                          仟                 佰                 拾                   '   '
          '   '             $4                 $3                 $2                   $1
          万           $8                 $7               $6                     $5
          亿           $12             $11           $10                 $9

          其中$i表示这个数字的第i个位置的数字,我们并不实际设定二维数组,我们得到的是数字的位置,
          要处理的该产生什么样的表示法,很简单这种处理方式往往就是:设pos表示数字位置,pos/4   在那一个段
          万以下段,万段,亿段.pos%4表示某一个段的段内位置,仟,佰,拾,由于叠加的缘故,即会有千万,百万,千亿等
          出现,因此这种设计是成立的.这里面隐含了一个问题就是,我们当前的处理的最大数字达千亿位,
          更大的数字用这种结构是不妥的,因为可能会有万亿,这时候推荐的想法是把这些设计成单维的数组结构,
          从而取得叠加的表示.
          4.循环处理各个位的过程中,我们可以预想到,零的问题是最难解决的.
          因为我们多个连续的零你只能出现一个表示,更有甚者,当某段全为0时,'零'还不能出现.
          因此这些问题综合考虑得到以下代码.


  代码:(JAVA描述)
  public   static   String   changeToBig(double   value){
          char[]   hunit={'拾','佰','仟'};                                                                                               //段内位置表示
          char[]   vunit={'万','亿'};                                                                                                           //段名表示
          char[]   digit={'零','壹','贰','叁','肆','伍','陆','柒','捌','玖'};     //数字表示
          long   midVal   =   (long)(value*100);                                                                             //转化成整形
          String   valStr=String.valueOf(midVal);                                                                 //转化成字符串
          String   head=valStr.substring(0,valStr.length()-2);                               //取整数部分
          String   rail=valStr.substring(valStr.length()-2);                                           //取小数部分

          String   prefix="";                                                                                                                                   //整数部分转化的结果
          String   suffix="";                                                                                                                                     //小数部分转化的结果
          //处理小数点后面的数
          if(rail.equals("00")){                                                                                                                         //如果小数部分为0
              suffix="整";
          }   else{
              suffix=digit[rail.charAt(0)-'0']+"角"+digit[rail.charAt(1)-'0']+"分";                 //否则把角分转化出来
          }
          //处理小数点前面的数
          char[]   chDig=head.toCharArray();                                                                                                                   //把整数部分转化成字符数组
          char   zero='0';                                                                                                                                                                                     //标志'0'表示出现过0
          byte   zeroSerNum   =   0;                                                                                                                                                         //连续出现0的次数
          for(int   i=0;i<chDig.length;i++){                                                                                                                               //循环处理每个数字
              int   idx=(chDig.length-i-1)%4;                                                                                                                                 //取段内位置
              int   vidx=(chDig.length-i-1)/4;                                                                                                                                 //取段位置
              if(chDig[i]=='0'){                                                                                                                                                                     //如果当前字符是0
                  zeroSerNum++;                                                                                                                                                                   //连续0次数递增
                  if(zero   ==   '0'){                                                                                                                                                                         //标志
                      zero=digit[0];
                  }   else   if(idx==0   &&   vidx   >0   &&zeroSerNum   <   4){
                      prefix   +=   vunit[vidx-1];
                      zero='0';
                  }
                  continue;
              }
              zeroSerNum   =   0;                                                                                                                                                                         //连续0次数清零
              if(zero   !=   '0')   {                                                                                                                                                                                 //如果标志不为0,则加上,例如万,亿什么的
                  prefix+=zero;
                  zero='0';
              }
              prefix+=digit[chDig[i]-'0'];                                                                                                                                                 //转化该数字表示
              if(idx   >   0)   prefix   +=   hunit[idx-1];
              if(idx==0   &&   vidx>0){
                  prefix+=vunit[vidx-1];                                                                                                                                                           //段结束位置应该加上段名如万,亿
              }
          }

          if(prefix.length()   >   0)   prefix   +=   '圆';                                                                                                                           //如果整数部分存在,则有圆的字样
          return   prefix+suffix;                                                                                                                                                                           //返回正确表示
      }

zephyr_cc 的方法很好，但是有代码错误，现改正如下：
package ch01;import java.text.DecimalFormat;public class ChineseCurrency{
    public static void main(String[] args) {
        double number = 13500035.53;
        System.out.println(toChineseCurrency(new Double(number)));
    }

    public static String toChineseCurrency(Object o) {
        if(o instanceof Number) {
            String s = new DecimalFormat("#.00").format(o);
            System.out.println(s);
            s = s.replaceAll("\\.", "");
            char[] digit = {'零', '壹', '贰', '叁', '肆',
                    '伍', '陆', '柒', '捌', '玖'};
            String unit = "仟佰拾兆仟佰拾亿仟佰拾万仟佰拾元角分";
            int l = unit.length();
            StringBuffer sb = new StringBuffer(unit);
            for(int i=s.length()-1; i>=0; i--)
                sb = sb.insert(l-s.length()+i, digit[(s.charAt(i) - 0x30)]);
            s = sb.substring(l-s.length(), l+s.length());
            s = s.replaceAll("零[拾佰仟]", "零").
                replaceAll("零{2,}", "零").
                replaceAll("零([兆万元])", "$1").
                replaceAll("零[角分]", "");
            return s;
        } else {
            throw new NumberFormatException();
        }
    }
}

参考 zephyr_cc 的方法import java.text.DecimalFormat;public class ChineseCurrency{
    public static void main(String[] args) {
        double number = 13500035.53;
        System.out.println(toChineseCurrency(new Double(number)));
    }

    public static String toChineseCurrency(Object o) {
        if(o instanceof Number) {
            String NumStr = new DecimalFormat("#.00").format(o);
            System.out.println(NumStr);
            NumStr = NumStr.replaceAll("\\.", "");
            String[] digit = { "零","壹","贰","叁","肆",
                     "伍","陆","柒","捌","玖"};
            String unit = "分角元拾佰仟万拾佰仟亿拾佰仟万拾佰仟亿拾佰仟......";
            int len = NumStr.length();
            string val="";
            for(int i=0;i<len;i++)
            {
             val=val + digit[(NumStr.charAt(i) - 0x30)]+unit.substring(len-1-i,1);
             if(digit[(NumStr.charAt(i) - 0x30)].Equals("零"))
             val = val.replaceAll("零零", "零")
            }
            return val.replaceAll("零亿","亿").replaceAll("零万","万").replaceAll("零元","元").replaceAll("零[角分]", "");

        } else {
            throw new NumberFormatException();
        }
    }
}

调试易

一个程序的编写

解决方案 »