一道java笔试题，以为很简单，结果半天都没写对！请大虾给出个正确解答

lamlamlam

上面的程序掉了一句，去除尾零的句子：
……
Cvalue=Cvalue.replaceFirst("亿万","亿");//去除亿万连接的非法情况
if(Cvalue.endsWith("零")) Cvalue=Cvalue.substring(0,Cvalue.length()-1);//去除尾零
System.out.println(Cvalue);
……
一个例子为：
1002003090：壹拾亿零贰佰零万叁仟零玖拾

kevinak123

import java.util.Hashtable;
import java.util.Vector;
class Converter {
        // 中国的计数是四位一个单位的处理方式 例如 1 5487 4584 对应的单位是 亿 万 默认
        // 每四位的一个单元中，处理方式是一样的,当前能够处理的最大绝对值位数是UNIT_NAME.length * 4
        private final static String[] UNIT_NAME = {"亿", "萬", ""};
        private final static String[] SUB_UNIT_NAME = {"仟", "佰", "拾"};
        private final static String[] NUMBER_NAME = {"零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"};
        private static Hashtable<Integer, String> nums = new Hashtable<Integer, String>();
        static {
                for (int i = 0; i < NUMBER_NAME.length; i++) {
                        nums.put(i, NUMBER_NAME[i]);
                }
        }
        public static String convert(long value) throws TooBigNumberException {
                boolean isMinus = value < 0;
                if (isMinus) {
                        value = Math.abs(value);
                }
                String result = "";
                String valueString = String.valueOf(value);
                char[] chars = valueString.toCharArray();
                if (chars.length > UNIT_NAME.length * 4) {
                        throw new TooBigNumberException();
                } else {
                        // 当前可以处理，进行四段分割，每部分进行相同的处理，再添加各自段的单位
                        String[] segments = splitValue2Segments(chars, 4);
                        for (int i = 0, j = UNIT_NAME.length - segments.length; i < segments.length; i++, j++) {
                                if (segments.length > 1 && i == segments.length - 1) {
                                        if (Integer.parseInt(segments[i]) < 100) {
                                                result += "零";
                                        }
                                }
                                if (Integer.parseInt(segments[i]) > 0) {
                                        result += translate(segments[i]) + UNIT_NAME[j];
                                }

                        }
                }
                if (isMinus) {
                        result = "负" + result;
                }
                return result;
        }
        /**
         * 将一个最多四个数的片段转换为自然语言表示方式 每一段由最多四为组成，最大数为9999
         *
         * @param value
         * @return
         */
        private static String translate(String value) {
                String result = "";
                int intValue = Integer.parseInt(value);
                int thousandBit = intValue / 1000;
                int hundredBit = (intValue - thousandBit * 1000) / 100;
                int tenthBit = (intValue - thousandBit * 1000 - hundredBit * 100) / 10;
                int oneBit = intValue - thousandBit * 1000 - hundredBit * 100 - tenthBit * 10;
                if (thousandBit > 0) {
                        result += nums.get(thousandBit) + "仟";
                        if (hundredBit > 0) {
                                result += nums.get(hundredBit) + "佰";
                                if (tenthBit > 0) {
                                        if (tenthBit > 1) {
                                                result += nums.get(tenthBit) + "拾";
                                        } else {
                                                result += "拾";
                                        }

                                        if (oneBit > 0) {
                                                result += nums.get(oneBit);
                                        }
                                } else {
                                        if (oneBit > 0) {
                                                result += "零";
                                                result += nums.get(oneBit);
                                        }
                                }
                        } else {
                                if (tenthBit > 0) {
                                        result += "零";
                                        if (tenthBit > 1) {
                                                result += nums.get(tenthBit) + "拾";
                                        } else {
                                                result += "拾";
                                        }

                                        if (oneBit > 0) {
                                                result += nums.get(oneBit);
                                        }
                                } else {
                                        if (oneBit > 0) {
                                                result += nums.get(oneBit);
                                        }

                                }

                        }
                } else {
                        if (hundredBit > 0) {
                                result += nums.get(hundredBit) + "佰";
                                if (tenthBit > 0) {
                                        if (tenthBit > 1) {
                                                result += nums.get(tenthBit) + "拾";
                                        } else {
                                                result += "拾";
                                        }

                                        if (oneBit > 0) {
                                                result += nums.get(oneBit);
                                        }
                                } else {
                                        if (oneBit > 0) {
                                                result += "零";
                                                result += nums.get(oneBit);
                                        }
                                }
                        } else {
                                if (tenthBit > 0) {
                                        if (tenthBit > 1) {
                                                result += nums.get(tenthBit) + "拾";
                                        } else {
                                                result += "拾";
                                        }
                                        if (oneBit > 0) {
                                                result += nums.get(oneBit);
                                        }
                                } else {
                                        if (oneBit > 0) {
                                                result += nums.get(oneBit);
                                        }
                                }
                        }
                }
                // System.out.println("Translating from " + value + " To :" + result);
                return result;
        }
        public static void main(String[] args) {
                try {
                        System.out.println(convert(1000000009));
                } catch (TooBigNumberException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
        }
        /**
         * 把字符数组分割为指定段数
         *
         * @param chars
         * @return
         */
        public static String[] splitValue2Segments(char[] chars, int segments) {
                int count = 0;
                Vector<String> v = new Vector<String>();
                StringBuffer sb = new StringBuffer();
                for (int i = chars.length - 1; i >= 0; i--) {
                        if (count >= segments) {
                                v.add(sb.toString());
                                sb = new StringBuffer();
                                count = 0;
                        }
                        sb.insert(0, chars[i]);
                        count++;
                }
                if (sb.length() > 0) {
                        v.add(sb.toString());
                }
                String[] result = new String[v.size()];
                for (int i = v.size() - 1, j = 0; i >= 0; i--) {
                        result[j++] = v.elementAt(i);
                        System.out.println(v.elementAt(i));
                }
                return result;
        }
}
class TooBigNumberException extends Exception {
        public String toString() {
                return "数值过大，当前系统无法处理。";
        }
}

abbygong

import java.util.ArrayList;
import java.util.regex.*;
public class MoneyTranslater {
        public static final String [] unitStrs={"","万","亿","兆"};
        public static final String [] numUnitStrs={"","拾","佰","仟"};
        public static final String [] numStrs={"零","壹","贰","叁","肆","伍","陆","柒","捌","玖"};
        public static String translate(String num){
                StringBuffer returnStr=new StringBuffer();
                //String num=String.valueOf(number);
                String [] strs1=splitByDigit(num, 4);
                boolean f=true;//类似于flag
                boolean f2=true;//类似于flag2
                boolean flag2=true;//可以补零 则为true
                for (int i = 0; i < strs1.length; i++) {
                        int m=Integer.valueOf(strs1[i]);
                        if(f){
                                if(m==0) continue;
                                else{
                                        f=false;
                                }
                        }
                       
                        if(m==0){
                                if(f2&&flag2){//如果在其后面的可以补零标志已经为true 并且区域可以补零 则补零
                                        returnStr.insert(0, numStrs[0]);
                                        f2=false;
                                }
                                continue;
                        }else{
                                f2=true;//若出现不为零的区域 则置区域补零标志为true
                        }
                        returnStr.insert(0, unitStrs[i]);
                        boolean flag=true;//如果从首位开始往前 出现第一个不为零的数 则为false;
                       
                        String [] strs2=splitByDigit(strs1[i],1);
                        for (int j = 0; j < strs2.length; j++) {
                                int n=Integer.valueOf(strs2[j]);
                                if(flag){
                                        if(n==0) continue;//在还没有出现第一个不为零的位时出现零 则跳过
                                        else{
                                                flag=false; //从个位开始已经出现不为零的数 可以开始计数
                                        }
                                }
                                if(n==0){
                                        if(flag2){
                                        returnStr.insert(0,numStrs[0]);
                                        flag2=false;//已经补了一个零 若再次出现0 则跳过 除非出现非零位之后
                                        }
                                        continue;
                                }else{
                                        flag2=true;//出现非零位 标志置为true 表示可以补零
                                }
                               
                                returnStr.insert(0, numUnitStrs[j]);
                                returnStr.insert(0, numStrs[n]);
                        }
                }
                return returnStr.toString();
        }
       

        /**
         * 这个方法实现将源操作字符串src,按给定的分割位数分割 比如
         * <code>String[] ss=splitByDigit("123456889abcdefg",4)</code>的结果是一个数组
         * @param src
         * @param digit
         * @return
         */
        public static String[] splitByDigit(String src,int digit){
                String destStr=src;
                ArrayList<String> list=new ArrayList<String>();
                while(destStr.length()>0){
                        if(destStr.length()>digit){
                                list.add(destStr.substring(destStr.length()-digit));
                                destStr=destStr.substring(0,destStr.length()-digit);
                        }else{
                                list.add(destStr);
                                destStr="";
                        }
                }
                String [] returnS=new String [list.size()];
                return list.toArray(returnS);
        }
        /**
         * @param args
         */
        public static void main(String[] args) {

                System.out.println(translate("12000001000001"));
               
               
        }
}
以上的unitStrs可以自己修改单位

abbygong

import java.util.ArrayList;
import java.util.regex.*;
public class MoneyTranslater {
        public static final String [] unitStrs={"","万","亿","兆"};
        public static final String [] numUnitStrs={"","拾","佰","仟"};
        public static final String [] numStrs={"零","壹","贰","叁","肆","伍","陆","柒","捌","玖"};
        public static String translate(String num){
                StringBuffer returnStr=new StringBuffer();
                //String num=String.valueOf(number);
                String [] strs1=splitByDigit(num, 4);
                boolean f=true;//类似于flag
                boolean f2=true;//类似于flag2
                boolean flag2=true;//可以补零 则为true
                boolean f3=true;//在每个大单位出现之后 是否能加零
                for (int i = 0; i < strs1.length; i++) {
                        int m=Integer.valueOf(strs1[i]);
                        if(f){
                                if(m==0) continue;
                                else{
                                        f=false;
                                }
                        }
                       
                        if(m==0){
                                if(f2&&flag2){//如果在其后面的可以补零标志已经为true 并且区域可以补零 则补零
                                        returnStr.insert(0, numStrs[0]);
                                        f2=false;
                                }
                                continue;
                        }else{
                                f2=true;//若出现不为零的区域 则置区域补零标志为true
                        }
                        returnStr.insert(0, unitStrs[i]);
                        boolean flag=true;//如果从首位开始往前 出现第一个不为零的数 则为false;
                       
                        String [] strs2=splitByDigit(strs1[i],1);
                        for (int j = 0; j < strs2.length; j++) {
                                int n=Integer.valueOf(strs2[j]);
                                if(flag){
                                        if(n==0){
                                                if(f3&&i!=0){
                                                        returnStr.insert(1, numStrs[0]);
                                                        f3=false;
                                                }
                                                continue;//在还没有出现第一个不为零的位时出现零 则跳过
                                               
                                        }
                                        else{
                                                flag=false; //从个位开始已经出现不为零的数 可以开始计数
                                        }
                                }
                                if(n==0){
                                        if(flag2){
                                        returnStr.insert(0,numStrs[0]);
                                        flag2=false;//已经补了一个零 若再次出现0 则跳过 除非出现非零位之后
                                        }
                                        continue;
                                }else{
                                        flag2=true;//出现非零位 标志置为true 表示可以补零
                                }
                               
                                returnStr.insert(0, numUnitStrs[j]);
                                returnStr.insert(0, numStrs[n]);
                        }
                        f3=true;
                }
                return returnStr.toString();
        }
       

        /**
         * 这个方法实现将源操作字符串src,按给定的分割位数分割 比如
         * <code>String[] ss=splitByDigit("123456889abcdefg",4)</code>的结果是一个数组
         * @param src
         * @param digit
         * @return
         */
        public static String[] splitByDigit(String src,int digit){
                String destStr=src;
                ArrayList<String> list=new ArrayList<String>();
                while(destStr.length()>0){
                        if(destStr.length()>digit){
                                list.add(destStr.substring(destStr.length()-digit));
                                destStr=destStr.substring(0,destStr.length()-digit);
                        }else{
                                list.add(destStr);
                                destStr="";
                        }
                }
                String [] returnS=new String [list.size()];
                return list.toArray(returnS);
        }
        /**
         * @param args
         */
        public static void main(String[] args) {

                System.out.println(translate("10200101001001"));
               
               
        }
}
做了一下修正 单位之间的零可以出现了

meisei

修正自己的程序
package jm.util;

import java.util.ArrayList;

/**
* <p>Title: JM 整合Swing控件，使用配置信息</p>
*
*/
public class JMRectangle
{
    @SuppressWarnings("unchecked")
        public static String daxie(String sum)
    {
        String [] n=new String[10];
        n[0]="";
        n[1]="壹";
        n[2]="贰";
        n[3]="叁";
        n[4]="肆";
        n[5]="伍";
        n[6]="陆";
        n[7]="柒";
        n[8]="捌";
        n[9]="玖";
        String [] d=new String[10];
        d[0]="";
        d[1]="拾";
        d[2]="佰";
        d[3]="仟";
        String [] e=new String[10];
        e[0]="萬";
        e[1]="亿";

        //计算数字的位数
        int wei= sum.length();
System.out.println("计算数字的位数=="+wei);

        ArrayList str = new ArrayList();
        int digit = 0;
        int digit1 = 0;
        for (int i = wei - 1; i >= 0; i--) {
            if (digit == 4) {
                digit = 0;
                str.add(0, e[digit1]);
                digit1++;
                if(digit1==2)digit1=0;
            }
            if (!"0".equals("" + sum.charAt(i))) {
                str.add(0, d[digit]);
                str.add(0, n[Integer.parseInt("" + sum.charAt(i))]);
            }
            digit++;
        }
        System.out.println(str);
        return str.toString();
    }

    public static void main(String[] args)
    {
        System.out.println(daxie("1234567890001"));
    }
}

简单好用

dazhuguale

楼上的写法不标准
(!"0".equals("" + sum.charAt(i))) 为什么不写成(!'0'==sum.charAt(i))
ArrayList str = new ArrayList();为什么不写成List str=new ArrayList();命名也不太规范
数组为什么不写成        private static String[] CHINESE_NUMBER = { "零", "壹", "贰", "叁", "肆", "伍",
                        "陆", "柒", "捌", "玖" };
根据你的意思ArrayList
换成StringBuffer好一些

dazhuguale

修正一下:('0'!=sum.charAt(i))

origle

偶也凑凑热闹：）
-----------------------------------------
public final class RMB{
   private RMB(){
   }

   /**
     * 将给定的阿拉伯数字转化为中文大写钱款
     *
     * @param input 给定的阿拉伯数字
     * @return 中文大写钱款
     */
    public static String toRMB(String input) {

        if (input == null || input.equals("")) {
            return "零";
        }

        // 判断输入是否为数字（方法不贴了，先注释了）
        //if (!isNumber(input)) {
        //    throw new IllegalArgumentException(
        //        "The money input must be a number!");
        //}

        // 判断是否含有小数点（将给定字符串四舍五入。方法不贴了，先注释了）
        //input = format(round(toDouble(input).doubleValue()));
        int dotIndex = input.indexOf(".");
        if (dotIndex > 0) {
            if (dotIndex == input.length() - 2) {
                input = input + "0";
            }
            else if (dotIndex == input.length() - 1) {
                input = input + "00";
            }
        }
        else {
            input = input + ".00";
        }

        // 最多位数：１５位数字
        if (dotIndex > 14) {
            throw new IllegalArgumentException(
                "The money input is too large to convert!");
        }

        final String[] numbers = new String[] {"零", "壹", "贰", "叁", "肆", "伍",
            "陆", "柒", "捌", "玖"};
        final String[] units = new String[] {"分", "角", "元", "拾", "佰", "仟", "万",
            "拾", "佰", "仟", "亿", "拾", "佰", "仟", "万"};
        final String[] invalids = new String[] {"拾零元", "零[仟佰拾元角分]", "零+", "零亿",
            "零万", "零元", "亿零*+万"};
        final String[] valids = new String[] {"拾元", "零", "零", "亿", "万", "元",
            "亿"};

        // 反转给定数字
        StringBuffer inputReversed = new StringBuffer(input).reverse();
        inputReversed.deleteCharAt(inputReversed.indexOf("."));

        // 按位转化并添加单位
        StringBuffer resultBuffer = new StringBuffer();
        int numberLength = inputReversed.length();
        for (int index = 0; index < numberLength; index++) {
            resultBuffer.append(units[index]);
            resultBuffer.append(numbers[Integer.parseInt(inputReversed.charAt(index)
                + "")]);
        }

        // 替换非法表达方式
        String result = resultBuffer.reverse().toString();
        for (int i = 0; i < invalids.length; i++) {
            result = result.replaceAll(invalids[i], valids[i]);
        }

        // 如果以零开头，则去掉零
        if (result.startsWith("零")) {
            result = result.substring(1, result.length());
        }
        // 如果以零结尾，则去掉零
        if (result.endsWith("零")) {
            result = result.substring(0, result.length() - 1);
        }
        // 如果没有角分，则添加整字
        if (result.indexOf("角") < 0 && result.indexOf("分") < 0) {
            result = result + "整";
        }

        return result;
    }
   
    public static void main(String[] args) {
        String money = "100000000010.12645";
        System.out.println(RMB.toRMB(money));

        String moneyString = "10.01";
        System.out.println(RMB.toRMB(moneyString));
    }
}

origle

hehe:)
String money = "100000000010.12645";
改成
String money = "100000000010.12";
注释了
没法保留二位小数然后四舍五入了：）、

ss80818

搞笑，ACCP软工培训S1试题