金额阿拉伯数转中文

package cc.boazy.vicp.util;

import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.HashSet;
import java.util.Set;

/**
 * 
 * @author Boazy
 * @date 2012-12-4
 */
public class AmountUtil
{
    /**
     * 定义中文零到玖常量数组 以数组索引对应对应的中文大写数
     */
    private static final char[] NUM_CAPITALS = {'零', '壹', '贰', '参', '肆', '伍', '陆', '柒', '捌', '玖'};

    /**
     * 定义中文单位
     */
    private static final char[] AMOUNT_UNITS = {'分', '角', '元', '拾', '佰', '仟', '万', '拾', '佰', '仟', '亿', '拾', '佰', '仟',
            '万', '兆', '拾', '佰', '仟', '万', '亿'};

    /**
     * 定义元万亿兆的索引
     */
    private static final Set<Integer> YWYZ_INDEX = new HashSet<Integer>();

    static
    {
        YWYZ_INDEX.add(2);
        YWYZ_INDEX.add(6);
        YWYZ_INDEX.add(10);
        YWYZ_INDEX.add(15);
    }

    /**
     * 将阿拉伯数转为中文大写
     * 
     * @param amount 阿拉伯数字符 （1051.08）
     * @return 转换后的中文大写数 （壹仟零伍拾壹元零捌分）
     */
    public static String toChineseCapital(String amount)
    {
        // 如果为空或等于零则返回空
        if (null == amount || amount.length() == 0)
        {
            return null;
        }

        // 将浮点型字符分隔为数组，索引为0的为整数部分、为1的为小数部分
        String[] zx = amount.split("\\.");
        int zxLen = zx.length;
        // 将amount拼成一个纯数的字符
        // 如1234→12300，1234.1→123410，1234.01→123401，1234.1254→123412
        StringBuilder aStr = new StringBuilder();
        if (zxLen >= 1)
        {
            aStr.append("".equals(zx[0]) ? "0" : zx[0]);
        }
        if (zxLen >= 2)
        {
            switch (zx[1].length())
            {
                case 0:
                    aStr.append("00");
                    break;
                case 1:
                    aStr.append(zx[1]).append("0");
                    break;
                case 2:
                    aStr.append(zx[1]);
                    break;
                default:
                    aStr.append(zx[1].substring(0, 2));
                    break;
            }
        }
        else
        {
            aStr.append("00");
        }

        // 当要处理的字符串已大于单位所能容纳，就抛算术异常
        if (aStr.length() > AMOUNT_UNITS.length)
        {
            throw new ArithmeticException("已大于单位所能容纳");
        }

        // 定义保存中文数的字符串变量
        StringBuilder chineseStr = new StringBuilder();
        // 将字符转为大整数
        BigInteger big = new BigInteger(aStr.toString());
        // 单位索引，初始为0
        int unitIndex = 0;
        /*
         * 循环从个位开始处理每个数转为中文大写 bi为每次循环后除10取整，当bi为0时处理结束
         */
        for (BigInteger bi = big; !"0".equals(bi.toString()); bi = bi.divide(BigInteger.TEN))
        {
            byte gw = bi.remainder(BigInteger.TEN).byteValue();
            
            int cStrLen = chineseStr.length();

            // gw不等于0 或 在指的在单位索引上，就添加单位
            if (0 != gw || YWYZ_INDEX.contains(unitIndex))
            {
                chineseStr.append(AMOUNT_UNITS[unitIndex]);
                
                String xx = cStrLen < 2 ? null : chineseStr.substring(cStrLen - 1);
                if("万亿".equals(xx) || "亿兆".equals(xx))
                {
                    chineseStr.delete(cStrLen - 1, cStrLen);
                }
            }

            /*
             * 如果个位数等于0时根据内层if过滤，否则直接添加中文数
             */
            if (0 == gw)
            {
                // 定义中文字符中最后一个字符变量
                String lastStr = null;
                if (chineseStr.length() > 0)
                {
                    lastStr = chineseStr.substring(chineseStr.length() - 1);
                }
                
                /*
                 * 如果最后一个字符不等于单位索引为2、6、10、16的字符， 并且等于"零"，就添加中文数"零"
                 * 并且lastStr不等于null
                 */
                if (null != lastStr && !lastStr.equals(String.valueOf(NUM_CAPITALS[0]))
                        && !lastStr.equals(String.valueOf(AMOUNT_UNITS[2]))
                        && !lastStr.equals(String.valueOf(AMOUNT_UNITS[6]))
                        && !lastStr.equals(String.valueOf(AMOUNT_UNITS[10]))
                        && !lastStr.equals(String.valueOf(AMOUNT_UNITS[15])))
                {
                    chineseStr.append(NUM_CAPITALS[gw]);
                }
            }
            else
            {
                chineseStr.append(NUM_CAPITALS[gw]);
            }

            // 每次循环后单位索引自增1
            unitIndex++;
        }

        /*
         * 此处已转换完成，将字符串反序后取最后一个字符判断是否等于"元" 是表示为整数就作处理，在反序后的中文字符最后加一个字符"整"
         */
        if (chineseStr.reverse().substring(chineseStr.length() - 1).equals(String.valueOf(AMOUNT_UNITS[2])))
        {
            chineseStr.append("整");
        }

        return chineseStr.toString();
    }
    
    public static String toChineseCapital(double amount)
    {
        return toChineseCapital(BigDecimal.valueOf(amount).toString());
    }
    
    public static String toChineseCapital(float amount)
    {
        return toChineseCapital(BigDecimal.valueOf(amount).toString());
    }
}