金额转化中文算法

最近要项目中用到了把数字类型的金额（1029.89元）转换成中文书写的方式（一仟零贰拾玖点八九元），参考了一些其他人写的算法，总觉得有些不太完善或者不严谨，例如10100转换成“十万一千元”，还是“十万零一千元”。我看到的一些算法都是转换成了前者，甚至iOS开发中支持中文转换的Api也是转换成了前者，但当我请教公司的财务同学时，给出的答案应该是后者。
所以，把自己写的转换过程分享出来，可能写的不是特别漂亮，欢迎大家指导。

抽象

第一步：抽象

面向对象编程中最重要的思想就是抽象，抽象成代码表示。

10100 —> 十万零一千元

中文数学计数采用的方式是
1、数字+权位。如100中 1 佰，1为数字位，佰为权位。权位包括：个、拾、佰、仟。
2、4位为一节，每一节有节权位，如：万、亿、兆。

所以根据以上特性，将每一位10100中的每一位抽象成中文的（数字+权位）。节权位没有数字，只有权位。

 /**
     * 中文数学计数
     * 数字+权位
     * 100中 1 佰，1为数字位，佰为权位
     * 权位包括 个 拾 佰 仟
     * 4位为一节，每一节有节权位如 万 亿 兆
     */
    private class ChinaMath {
        private String num;
        private String weight;

        public ChinaMath(String num, String weight) {
            this.num = num;
            this.weight = weight;
        }

        public String getNum() {
            return num;
        }

        public String getWeight() {
            return weight;
        }

        /**
         * 是否是节权位
         *
         * @return 当num为空时，返回true，否则返回false
         */
        public boolean isSectionWeight() {
            return (num == null || "".equalsIgnoreCase(num.trim()));
        }

        @Override
        public String toString() {
            return "ChinaMath{" +
                    "num='" + num + '\'' +
                    ", weight='" + weight + '\'' +
                    '}';
        }
    }

转换

第二步：转换

先遍历整个金额，简单的转换为中文表示后的列表ChinaMath[]。
如：11001 —> 壹 万 壹仟 零佰 零拾 壹

String integerPart = "10001";
List<ChinaMath> intPart = new ArrayList<>();
        //从低位到高位遍历
        for (int i = len - 1; i >= 0; i--) {
            //数字的地位
            int lowerIndex = len - i - 1;
            //字符串的高位
            char lowerChar = integerPart.charAt(i);

            int remainderDivide4 = lowerIndex % 4;

            if (remainderDivide4 == 0) {
                intPart.add(0, new ChinaMath("", unit[lowerIndex / 4]));
            }
            intPart.add(0, new ChinaMath(transferSingleNum(Character.getNumericValue(lowerChar)), places[remainderDivide4]));
        }

过滤+转换

第三步：过滤+转换

这一步是最麻烦的，我们要以第二步的结果为基础，再根据中文的金额读写特点进行加工。
例如：

1. 金额中间有多个0，只读一个零
2. 金额末尾有多个0，都不读
3. 10要读拾，不能读成壹拾
4. 文章开头提到，节权位前的零不能省

List<String> result = new ArrayList<>();
int chinaMatchLen = intPart.size();
        for (int i = 0; i < chinaMatchLen; i++) {
            ChinaMath chinaMath = intPart.get(i);
            String num = chinaMath.getNum();
            String weight = chinaMath.getWeight();
            if (isNotNull(num)) {
                //如果数字是0，则判断下一个数字或者是否是0 或者是否是节权位
                //如果不是，则现在要添加一个0，否则不添加
                if (num.equalsIgnoreCase(CHINEASE_DIGIT[0])) {
                    String nextNumOrSectionWeight = intPart.get(i + 1).getNum();
                    if (!CHINEASE_DIGIT[0].equalsIgnoreCase(nextNumOrSectionWeight)) {
                        integerList.add(CHINEASE_DIGIT[0]);
                    }
                } else {
                    //添加数字和权位
                    if (num.equalsIgnoreCase(CHINEASE_DIGIT[1]) && weight.equalsIgnoreCase(places[1]) && i == 0) {
                        //如果十位是1，则读成拾，而不是壹拾
                        if (isNotNull(weight)) {
                            integerList.add(weight);
                        }
                    } else {
                        integerList.add(num);
                        if (isNotNull(weight)) {
                            integerList.add(weight);
                        }
                    }
                }
            }

            //节权位并且不为空，因为个位也是节权位，但没有实际值
            boolean isSectionWight = chinaMath.isSectionWeight();
            if (isSectionWight) {
                String lastNum = intPart.get(i - 1).getNum();
                //如果是正常的节权位
                if (isNotNull(chinaMath.getWeight())) {
                    String nextNum = intPart.get(i + 1).getNum();

                    if (lastNum.equalsIgnoreCase(CHINEASE_DIGIT[0])) {
                        if (!nextNum.equalsIgnoreCase(CHINEASE_DIGIT[0])) {
                            //前一位是0，后一位不是0，则交换节权位和前一位的位置，例0万 -> 万0
                            integerList.set(integerList.size() - 1, chinaMath.getWeight());
                            integerList.add(CHINEASE_DIGIT[0]);
                        } else {
                            //前一位是0，后一位是0，需要把前一位的0去掉
                            integerList.remove(integerList.size() - 1);
                            integerList.add(chinaMath.getWeight());
                        }
                    } else {
                        //前一位不是0， 直接添加节权位
                        integerList.add(chinaMath.getWeight());
                    }
                } else {
                    //最后一个节权位，如果上一位是0，并且不仅有一个0，移除个位多余的0
                    if (lastNum.equalsIgnoreCase(CHINEASE_DIGIT[0]) && integerList.size() > 1) {
                        integerList.remove(integerList.size() - 1);
                    }
                }
            }
        }
        result.addAll(0, integerList);

        result.add(YUAN);

测试

0.12 -> [zero, point, one, two, yuan]
0.02 -> [zero, point, zero, two, yuan]
1005.20 -> [one, thousand, zero, five, point, two, yuan]
1234.30 -> [one, thousand, two, hundred, three, ten, four, point, three, yuan]
120 3023.02 -> [one, hundred, two, ten, wan, zero, three, thousand, zero, two, ten, three, point, zero, two, yuan]
1000 0003.02 -> [one, thousand, wan, zero, three, point, zero, two, yuan]
10.13 -> [ten, point, one, three, yuan]
1000 0703.02 -> [one, thousand, wan, zero, seven, hundred, zero, three, point, zero, two, yuan]
0010.13 -> [ten, point, one, three, yuan]
110.13 -> [one, hundred, one, ten, point, one, three, yuan]
12100010.13 -> [one, thousand, two, hundred, one, ten, wan, zero, one, ten, point, one, three, yuan]

从测试结果可以看出，所有特殊情况的金额都转换正确了。初次之外，在转换之前做了一些严格的参数判断和简单的格式化操作，保证输入的合法性。

附完整源码：

/**
 * 数字转换成大写汉字
 * <p>
 * 最大支持到千万
 * <p>
 * 1234 5678 .90
 * <p>
 * <p>
 * Created by joye on 2017/6/28.
 */

public class DigitTransfer2Chinese {

    /**
     * 小数点
     */
    protected final String DECIMAL_POINT = ".";

    /**
     * 中文大写数字
     */
    public static final String[] CHINEASE_DIGIT = {"zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"};


    public static final String[] unit = {"", "wan"};

    public static final String[] places = {"", "ten", "hundred", "thousand"};

    public static final String DIAN = "point";

    public static final String YUAN = "yuan";

    /**
     * 支持转义的小数最大精确度
     */
    private final int MAX_DECIMAL_PRECISION = 2;

    /**
     * 支持转义的最大位数
     */
    private final int MAX_DIGIT_BITS = 8;

    /**
     * 将数字转换为中文大写文字
     *
     * @param digit 小数
     * @return 中文大写
     * @throws IllegalArgumentException 参数异常
     */
    public List<String> transfer(float digit) throws IllegalArgumentException {
        if (digit <= 0) {
            throw new IllegalArgumentException("the param must be greater than zero, but the digit is " + digit);
        }
        return transfer(String.valueOf(digit));
    }

    /**
     * 将字符串类型数字转换为中文大写文字
     *
     * @param digit 字符串类型的数字
     * @return 中文大写
     * @throws IllegalArgumentException 参数异常
     */
    public List<String> transfer(String digit) throws IllegalArgumentException {
        //判断是否为空
        if (digit == null || digit.length() == 0) {
            throw new IllegalArgumentException("param must not be empty, but the digit is " + digit);
        }
        //去除空格
        digit = removeBlank(digit);

        //判断是否包含非法字符（小数点除外）
        if (!isAllNum(digit)) {
            throw new IllegalArgumentException("param must all be number, but the digit is " + digit);
        }
        //判断是否超出最大位数
        if (isOverMaxBits(digit)) {
            throw new IllegalArgumentException("param's max bits is " + MAX_DIGIT_BITS + ", but the digit is " + digit);
        }
        //判断是否超出小数精确度
        if (isOverMaxDecimalPrecision(digit)) {
            throw new IllegalArgumentException("param's max decimal precision is " + MAX_DECIMAL_PRECISION + ", but the digit is " + digit);
        }
        //判断是否以小数点结尾
        if (isDecimalPointEnding(digit)) {
            throw new IllegalArgumentException("param can not end with . , but the digit is " + digit);
        }

        digit = removeInvalidZero(digit);
        return transferInternal(digit);
    }

    private String reverse(String source) {
        int len = source.length();
        if (len == 0 || len == 1) {
            return source;
        }
        char[] chars = source.toCharArray();
        int replaceTime = len / 2;
        for (int i = 0; i < replaceTime; i++) {
            char temp = chars[i];
            chars[i] = chars[len - 1 - i];
            chars[len - 1 - i] = temp;
        }
        return String.valueOf(chars);
    }

    private String removeBlank(String digit) {
        return digit.replace(" ", "");
    }

    //是否以小数点结尾
    private boolean isDecimalPointEnding(String digit) {
        return digit.endsWith(DECIMAL_POINT);
    }

    //是否超出最大小数精确度
    private boolean isOverMaxDecimalPrecision(String digit) {
        if (!digit.contains(DECIMAL_POINT)) {
            return false;
        }
        String decimalPartWithPoint = digit.substring(digit.indexOf(DECIMAL_POINT), digit.length());
        return decimalPartWithPoint.length() > MAX_DECIMAL_PRECISION + 1;
    }

    //是否超出最大位数
    private boolean isOverMaxBits(String digit) {
        String integerPart = digit;
        if (digit.contains(DECIMAL_POINT)) {
            integerPart = digit.substring(0, digit.indexOf(DECIMAL_POINT));
        }
        return integerPart.length() > MAX_DIGIT_BITS;
    }

    //是否全是数字 小数点除外
    private boolean isAllNum(String digit) {
        int len = digit.length();
        for (int i = 0; i < len; i++) {
            char temp = digit.charAt(i);
            if (!String.valueOf(temp).equals(DECIMAL_POINT) && (temp < '0' || temp > '9')) {
                return false;
            }
        }
        return true;
    }

    //去除无效的0
    private String removeInvalidZero(String origin) {
        //去除末尾的0
        if (origin.contains(DECIMAL_POINT)) {
            if (origin.endsWith(".00") || origin.endsWith(".0")) {
                origin = origin.substring(0, origin.indexOf(DECIMAL_POINT));
            }
            while (origin.endsWith("0")) {
                origin = origin.substring(0, origin.length() - 1);
            }
        }

        while ("0".equalsIgnoreCase(String.valueOf(origin.charAt(0))) && (origin.length() >= 2 && !DECIMAL_POINT.equalsIgnoreCase(String.valueOf(origin.charAt(1))))) {
            origin = origin.substring(1, origin.length());
        }

        return origin;
    }

    private List<String> transferInternal(String digit) {
        List<String> result = new ArrayList<>();

        String integerPart = digit;
        if (digit.contains(DECIMAL_POINT)) {
            result = transferDecimal(digit.substring(digit.indexOf(DECIMAL_POINT), digit.length()));
            integerPart = digit.substring(0, digit.indexOf(DECIMAL_POINT));
        }

        int len = integerPart.length();
        List<String> integerList = new ArrayList<>();
        List<ChinaMath> intPart = new ArrayList<>();
        //从低位到高位遍历
        for (int i = len - 1; i >= 0; i--) {
            //数字的地位
            int lowerIndex = len - i - 1;
            //字符串的高位
            char lowerChar = integerPart.charAt(i);

            int remainderDivide4 = lowerIndex % 4;

            if (remainderDivide4 == 0) {
                intPart.add(0, new ChinaMath("", unit[lowerIndex / 4]));
            }
            intPart.add(0, new ChinaMath(transferSingleNum(Character.getNumericValue(lowerChar)), places[remainderDivide4]));
        }

        int chinaMatchLen = intPart.size();
        for (int i = 0; i < chinaMatchLen; i++) {
            ChinaMath chinaMath = intPart.get(i);
            String num = chinaMath.getNum();
            String weight = chinaMath.getWeight();
            if (isNotNull(num)) {
                //如果数字是0，则判断下一个数字或者是否是0 或者是否是节权位
                //如果不是，则现在要添加一个0，否则不添加
                if (num.equalsIgnoreCase(CHINEASE_DIGIT[0])) {
                    String nextNumOrSectionWeight = intPart.get(i + 1).getNum();
                    if (!CHINEASE_DIGIT[0].equalsIgnoreCase(nextNumOrSectionWeight)) {
                        integerList.add(CHINEASE_DIGIT[0]);
                    }
                } else {
                    //添加数字和权位
                    if (num.equalsIgnoreCase(CHINEASE_DIGIT[1]) && weight.equalsIgnoreCase(places[1]) && i == 0) {
                        //如果十位是1，则读成拾，而不是壹拾
                        if (isNotNull(weight)) {
                            integerList.add(weight);
                        }
                    } else {
                        integerList.add(num);
                        if (isNotNull(weight)) {
                            integerList.add(weight);
                        }
                    }
                }
            }

            //节权位并且不为空，因为个位也是节权位，但没有实际值
            boolean isSectionWight = chinaMath.isSectionWeight();
            if (isSectionWight) {
                String lastNum = intPart.get(i - 1).getNum();
                //如果是正常的节权位
                if (isNotNull(chinaMath.getWeight())) {
                    String nextNum = intPart.get(i + 1).getNum();

                    if (lastNum.equalsIgnoreCase(CHINEASE_DIGIT[0])) {
                        if (!nextNum.equalsIgnoreCase(CHINEASE_DIGIT[0])) {
                            //前一位是0，后一位不是0，则交换节权位和前一位的位置，例0万 -> 万0
                            integerList.set(integerList.size() - 1, chinaMath.getWeight());
                            integerList.add(CHINEASE_DIGIT[0]);
                        } else {
                            //前一位是0，后一位是0，需要把前一位的0去掉
                            integerList.remove(integerList.size() - 1);
                            integerList.add(chinaMath.getWeight());
                        }
                    } else {
                        //前一位不是0， 直接添加节权位
                        integerList.add(chinaMath.getWeight());
                    }
                } else {
                    //最后一个节权位，如果上一位是0，并且不仅有一个0，移除个位多余的0
                    if (lastNum.equalsIgnoreCase(CHINEASE_DIGIT[0]) && integerList.size() > 1) {
                        integerList.remove(integerList.size() - 1);
                    }
                }
            }
        }
        result.addAll(0, integerList);

        result.add(YUAN);

        return result;
    }

    /**
     * 中文数学计数
     * 数字+权位
     * 100中 1 佰，1位数字位，佰为权位
     * 权位包括 个 拾 佰 仟
     * 4位为一节，每一节有节权位如 万 亿 兆
     */
    private class ChinaMath {
        private String num;
        private String weight;

        public ChinaMath(String num, String weight) {
            this.num = num;
            this.weight = weight;
        }

        public String getNum() {
            return num;
        }

        public String getWeight() {
            return weight;
        }

        /**
         * 是否是节权位
         *
         * @return 当num为空时，返回true，否则返回false
         */
        public boolean isSectionWeight() {
            return (num == null || "".equalsIgnoreCase(num.trim()));
        }

        @Override
        public String toString() {
            return "ChinaMath{" +
                    "num='" + num + '\'' +
                    ", weight='" + weight + '\'' +
                    '}';
        }
    }

    private boolean isNotNull(String string) {
        return string != null && !"".equalsIgnoreCase(string);
    }

    /**
     * 转换小数
     *
     * @param decimalWithPoint 小数部分（带小数点）
     * @return 小数部分的转换结果
     */
    private List<String> transferDecimal(String decimalWithPoint) {
        List<String> result = new ArrayList<>(3);
        if (decimalWithPoint.startsWith(DECIMAL_POINT)) {
            result.add(DIAN);
        }
        String decimalWithoutPoint = decimalWithPoint.replace(DECIMAL_POINT, "");
        int len = decimalWithoutPoint.length();
        for (int i = 0; i < len; i++) {
            int num = Character.getNumericValue(decimalWithoutPoint.charAt(i));
            result.add(transferSingleNum(num));
        }
        return result;
    }

    //转换单个数字
    private String transferSingleNum(int num) {
        return CHINEASE_DIGIT[num];
    }
}