金额转换，两千万、2000万转成20000000.00

已于 2023-06-12 14:21:09 修改
阅读量84 收藏
点赞数
文章标签： java
于 2023-06-12 10:07:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45483921/article/details/131163192
版权 
 /**
 * @description  大写转阿拉伯数字
 * @author  ycy
 * @param	cnTraditionalNum
 */
public static String method1(String cnTraditionalNum) {
    //规范错误字符
    cnTraditionalNum = cnTraditionalNum
            .replaceAll("億", "亿")
            .replaceAll("萬", "万")
            .replaceAll("千", "仟")
            .replaceAll("阡", "仟")
            .replaceAll("百", "佰")
            .replaceAll("元", "圆")
            .replaceAll("圓", "圆")
    ;

    long result = 0;

    if (cnTraditionalNum.contains("亿")) {
        String yi = cnTraditionalNum.substring(0, cnTraditionalNum.indexOf("亿"));
        result += cnThousandNumberToArab(yi) * 100000000L;
        cnTraditionalNum = cnTraditionalNum.substring(cnTraditionalNum.indexOf("亿"));
    }

    if (cnTraditionalNum.contains("万")) {
        String wan = cnTraditionalNum.substring(0, cnTraditionalNum.indexOf("万"));
        result += cnThousandNumberToArab(wan) * 10000L;
        cnTraditionalNum = cnTraditionalNum.substring(cnTraditionalNum.indexOf("万"));
    }


    if (cnTraditionalNum.contains("圆")) {
        String wan = cnTraditionalNum.substring(0, cnTraditionalNum.indexOf("圆"));
        result += cnThousandNumberToArab(wan);
        cnTraditionalNum = cnTraditionalNum.substring(cnTraditionalNum.indexOf("圆"));
    }

    //小数点后
    String jiao = "0";
    String fen = "0";
    String resultStr = String.valueOf(result);
    if (cnTraditionalNum.contains("角")) {
        jiao = cnNumToArabicNumMap.get(cnTraditionalNum.substring(cnTraditionalNum.indexOf("角") - 1, cnTraditionalNum.indexOf("角"))).toString();
    }
    if (cnTraditionalNum.contains("分")) {
        fen = cnNumToArabicNumMap.get(cnTraditionalNum.substring(cnTraditionalNum.indexOf("分") - 1, cnTraditionalNum.indexOf("分"))).toString();
    }

    resultStr += "." + jiao + fen;
    return resultStr;
}

private static Map<String, Integer> cnNumToArabicNumMap;

static {
    cnNumToArabicNumMap = new HashMap<>();
    cnNumToArabicNumMap.put("零", 0);
    cnNumToArabicNumMap.put("壹", 1);
    cnNumToArabicNumMap.put("一", 1);
    cnNumToArabicNumMap.put("贰", 2);
    cnNumToArabicNumMap.put("貳", 2);
    cnNumToArabicNumMap.put("二", 2);
    cnNumToArabicNumMap.put("两", 2);
    cnNumToArabicNumMap.put("叁", 3);
    cnNumToArabicNumMap.put("参", 3);
    cnNumToArabicNumMap.put("三", 3);
    cnNumToArabicNumMap.put("四", 4);
    cnNumToArabicNumMap.put("肆", 4);
    cnNumToArabicNumMap.put("五", 5);
    cnNumToArabicNumMap.put("伍", 5);
    cnNumToArabicNumMap.put("陆", 6);
    cnNumToArabicNumMap.put("六", 6);
    cnNumToArabicNumMap.put("柒", 7);
    cnNumToArabicNumMap.put("七", 7);
    cnNumToArabicNumMap.put("八", 8);
    cnNumToArabicNumMap.put("捌", 8);
    cnNumToArabicNumMap.put("九", 9);
    cnNumToArabicNumMap.put("玖", 9);
}

/**
 * 将大写数字转换为阿拉伯数字（数字小于一万）
 */
private static long cnThousandNumberToArab(String number) {
    int result = 0;

    if (number.indexOf("拾") <= 0
            || !cnNumToArabicNumMap.containsKey(String.valueOf(number.charAt(number.indexOf("拾") - 1)))) {
        number = number.replace("拾", "壹拾");
    }
    if (number.contains("仟")) {
        result += getArabicValue(number.charAt(number.indexOf("仟") - 1)) * 1000;
    }
    if (number.contains("佰")) {
        result += getArabicValue(number.charAt(number.indexOf("佰") - 1)) * 100;
    }
    if (number.contains("拾")) {
        result += getArabicValue(number.charAt(number.indexOf("拾") - 1)) * 10;
    }
    if (cnNumToArabicNumMap.containsKey(number.substring(number.length() - 1))) {
        result += cnNumToArabicNumMap.get(number.substring(number.length() - 1));
    }
    return result;
}

private static int getArabicValue(Character num) {
    Integer result = cnNumToArabicNumMap.get(num.toString());
    if (result == null)
        throw new IllegalArgumentException("不支持将该中文字符[" + num + "]转换为阿拉伯数字！");
    return result;
}

private static Pattern p1 = Pattern.compile("(\\d+)(\\.\\d+)?亿");
private static Pattern p21 = Pattern.compile("千万(\\d+)(\\.\\d+)?");
private static Pattern p22 = Pattern.compile("仟万(\\d+)(\\.\\d+)?");
private static Pattern p31 = Pattern.compile("(\\d+)(\\.\\d+)?千");
private static Pattern p32 = Pattern.compile("(\\d+)(\\.\\d+)?仟");
private static Pattern p2 = Pattern.compile("(\\d+)(\\.\\d+)?万");
private static Pattern p3 = Pattern.compile("(\\d+)(\\.\\d+)?元");
private static Pattern p4 = Pattern.compile("百万(\\d+)(\\.\\d+)?");
private static Pattern p5 = Pattern.compile("佰万(\\d+)(\\.\\d+)?");
private static Pattern p41 = Pattern.compile("(\\d+)(\\.\\d+)?百");
private static Pattern p42 = Pattern.compile("(\\d+)(\\.\\d+)?佰");
private static Pattern p51 = Pattern.compile("(\\d+)(\\.\\d+)?百万");
private static Pattern p52 = Pattern.compile("(\\d+)(\\.\\d+)?佰万");
private static Pattern p61 = Pattern.compile("(\\d+)(\\.\\d+)?千万");
private static Pattern p62 = Pattern.compile("(\\d+)(\\.\\d+)?仟万");
private static Pattern p7 = Pattern.compile("(\\d+)(\\.\\d+)?十万");
private static Pattern p8 = Pattern.compile("(\\d+)(\\.\\d+)?拾万");
private static Pattern p71 = Pattern.compile("十万(\\d+)(\\.\\d+)?");
private static Pattern p81 = Pattern.compile("拾万(\\d+)(\\.\\d+)?");
private static Pattern p9 = Pattern.compile("(\\d+)(\\.\\d+)?十");
private static Pattern p91 = Pattern.compile("(\\d+)(\\.\\d+)?拾");


/**
 * @description  小写数字+汉字转成纯数字
 * @author  ycy
 * @param	s
 */
public static String method2(String s) throws Exception {
    //        String regex = "^[0-9]+(\\.[0-9]+)?[亿万元]+([0-9]+[亿万])?([0-9]+[元])?$";
    //        String regex = "^[0-9]+(\\.[0-9]+)?[亿万元]+([0-9]+[亿万])?([0-9]+[元])?$";
    if (s.contains("整")){
        s=s.replace("整","");
    }
    if (s.contains("人民币")){
        s=s.replace("人民币","");
    }
    String regex = "(\\d+(\\.\\d+)?[亿|万|十|拾|千|仟|百|佰|十]*[元|万]?)+";
    if(!s.matches(regex)){
        throw new Exception();
    }
    Long sum = 0L;
    //Pattern p1 = Pattern.compile("(\\d+)(\\.\\d+)?亿");
    Matcher m1 = p1.matcher(s);
    if (m1.find()) {
        String num = m1.group(1);
        sum = sum + Long.valueOf(num) * 100000000;
        //System.out.println(num + "亿");
    }

    boolean containsQianWan = s.matches(".*千万.*");
    boolean containsQian = s.matches(".*千(?!万).*");
    boolean containsBoth = containsQianWan && containsQian;

    boolean containsQianWanq = s.matches(".*仟万.*");
    boolean containsQianq = s.matches(".*千(?!万).*");
    boolean containsBothq = containsQianWanq && containsQianq;


    boolean containsQianWanq1 = s.matches(".*千万.*");
    boolean containsQianq1 = s.matches(".*仟(?!万).*");
    boolean containsBothq1 = containsQianWanq1 && containsQianq1;


    boolean containsQianWanq11 = s.matches(".*仟万.*");
    boolean containsQianq11 = s.matches(".*仟(?!万).*");
    boolean containsBothq11 = containsQianWanq11 && containsQianq11;

    if (containsBoth || containsBothq || containsBothq1 || containsBothq11){
        //Pattern p21 = Pattern.compile("千万(\\d+)(\\.\\d+)?");
        Matcher m21 = p21.matcher(s);
        if (m21.find()) {
            String num = m21.group(1);
            sum = sum + Long.valueOf(num) * 1000;
            //System.out.println(num + "千");
        }
        //Pattern p22 = Pattern.compile("仟万(\\d+)(\\.\\d+)?");
        Matcher m22 = p22.matcher(s);
        if (m22.find()) {
            String num = m22.group(1);
            sum = sum + Long.valueOf(num) * 1000;
            //System.out.println(num + "千");
        }

    }else if ((!s.matches(".*千万.*")) && !s.matches(".*仟万.*")){
        //Pattern p31 = Pattern.compile("(\\d+)(\\.\\d+)?千");
        Matcher m31 = p31.matcher(s);
        if (m31.find()) {
            String num = m31.group(1);
            sum = sum + Long.valueOf(num) * 1000;
            //System.out.println(num + "千");
        }

        //Pattern p32 = Pattern.compile("(\\d+)(\\.\\d+)?仟");
        Matcher m32 = p32.matcher(s);
        if (m32.find()) {
            String num = m32.group(1);
            sum = sum + Long.valueOf(num) * 1000;
            //System.out.println(num + "千");
        }

    }



    //Pattern p2 = Pattern.compile("(\\d+)(\\.\\d+)?万");
    Matcher m2 = p2.matcher(s);
    if (m2.find()) {
        String num = m2.group(1);
        sum = sum + Long.valueOf(num) * 10000;
        //System.out.println(num + "万");
    }


    //Pattern p3 = Pattern.compile("(\\d+)(\\.\\d+)?元");
    Matcher m3 = p3.matcher(s);
    if (m3.find()) {
        String num = m3.group(1);
        sum = sum + Long.valueOf(num);
        //System.out.println(num + "元");
    }

    boolean containsQianWan2 = s.matches(".*百万.*");
    boolean containsQian2 = s.matches(".*百(?!万).*");
    boolean containsBoth2 = containsQianWan2 && containsQian2;


    boolean containsQianWan2q = s.matches(".*佰万.*");
    boolean containsQian2q = s.matches(".*百(?!万).*");
    boolean containsBoth2q = containsQianWan2q && containsQian2q;


    boolean containsQianWan2q1 = s.matches(".*百万.*");
    boolean containsQian2q1 = s.matches(".*佰(?!万).*");
    boolean containsBoth2q1 = containsQianWan2q1 && containsQian2q1;


    boolean containsQianWan2q11 = s.matches(".*佰万.*");
    boolean containsQian2q11 = s.matches(".*佰(?!万).*");
    boolean containsBoth2q11 = containsQianWan2q11 && containsQian2q11;

    if (containsBoth2 || containsBoth2q || containsBoth2q1 || containsBoth2q11){
        //Pattern p4 = Pattern.compile("百万(\\d+)(\\.\\d+)?");
        Matcher m4 = p4.matcher(s);
        if (m4.find()) {
            String num = m4.group(1);
            sum = sum + Long.valueOf(num) * 100;
            //System.out.println(num + "百万");
        }

        //Pattern p5 = Pattern.compile("佰万(\\d+)(\\.\\d+)?");
        Matcher m5 = p5.matcher(s);
        if (m5.find()) {
            String num = m5.group(1);
            sum = sum + Long.valueOf(num) * 100;
            //System.out.println(num + "百万");
        }

    }else if ((!s.matches(".*佰万.*")) && !s.matches(".*百万.*")){
        //Pattern p41 = Pattern.compile("(\\d+)(\\.\\d+)?百");
        Matcher m41 = p41.matcher(s);
        if (m41.find()) {
            String num = m41.group(1);
            sum = sum + Long.valueOf(num) * 100;
            //System.out.println(num + "百万");
        }

        //Pattern p42 = Pattern.compile("(\\d+)(\\.\\d+)?佰");
        Matcher m42 = p42.matcher(s);
        if (m42.find()) {
            String num = m42.group(1);
            sum = sum + Long.valueOf(num) * 100;
            //System.out.println(num + "百万");
        }
    }

    //Pattern p51 = Pattern.compile("(\\d+)(\\.\\d+)?百万");
    Matcher m51 = p51.matcher(s);
    if (m51.find()) {
        String num = m51.group(1);
        sum = sum + Long.valueOf(num) * 1000000;
        //System.out.println(num + "百万");
    }

    //Pattern p52 = Pattern.compile("(\\d+)(\\.\\d+)?佰万");
    Matcher m52 = p52.matcher(s);
    if (m52.find()) {
        String num = m52.group(1);
        sum = sum + Long.valueOf(num) * 1000000;
        //System.out.println(num + "百万");
    }

    //Pattern p61 = Pattern.compile("(\\d+)(\\.\\d+)?千万");
    Matcher m61 = p61.matcher(s);
    if (m61.find()) {
        String num = m61.group(1);
        sum = sum + Long.valueOf(num) * 10000000;
        //System.out.println(num + "千万");
    }

    //Pattern p62 = Pattern.compile("(\\d+)(\\.\\d+)?仟万");
    Matcher m62 = p62.matcher(s);
    if (m62.find()) {
        String num = m62.group(1);
        sum = sum + Long.valueOf(num) * 10000000;
        //System.out.println(num + "千万");
    }


    //Pattern p7 = Pattern.compile("(\\d+)(\\.\\d+)?十万");
    Matcher m7 = p7.matcher(s);
    if (m7.find()) {
        String num = m7.group(1);
        sum = sum + Long.valueOf(num) * 100000;
        //System.out.println(num + "十万");
    }

    //Pattern p71 = Pattern.compile("(\\d+)(\\.\\d+)?拾万");
    Matcher m8 = p8.matcher(s);
    if (m8.find()) {
        String num = m8.group(1);
        sum = sum + Long.valueOf(num) * 100000;
        //System.out.println(num + "十万");
    }


    boolean containsQianWan3 = s.matches(".*十万.*");
    boolean containsQian3 = s.matches(".*十(?!万).*");
    boolean containsBoth3 = containsQianWan3 && containsQian3;


    boolean containsQianWan3q = s.matches(".*十万.*");
    boolean containsQian3q = s.matches(".*拾(?!万).*");
    boolean containsBoth3q = containsQianWan3q && containsQian3q;

    boolean containsQianWan3q1 = s.matches(".*拾万.*");
    boolean containsQian3q1 = s.matches(".*十(?!万).*");
    boolean containsBoth3q1 = containsQianWan3q1 && containsQian3q1;

    boolean containsQianWan3q11 = s.matches(".*拾万.*");
    boolean containsQian3q11 = s.matches(".*拾(?!万).*");
    boolean containsBoth3q11 = containsQianWan3q11 && containsQian3q11;

    if (containsBoth3 || containsBoth3q || containsBoth3q1 || containsBoth3q11){
        //Pattern p71 = Pattern.compile("十万(\\d+)(\\.\\d+)?");
        Matcher m71 = p71.matcher(s);
        if (m71.find()) {
            String num = m71.group(1);
            sum = sum + Long.valueOf(num) * 10;
            //System.out.println(num + "十万");
        }
        //Pattern p81 = Pattern.compile("拾万(\\d+)(\\.\\d+)?");
        Matcher m81 = p81.matcher(s);
        if (m81.find()) {
            String num = m81.group(1);
            sum = sum + Long.valueOf(num) * 10;
            //System.out.println(num + "十万");
        }
    }else if((!s.matches(".*十万.*")) && !s.matches(".*拾万.*")){
        //Pattern p9 = Pattern.compile("(\\d+)(\\.\\d+)?十");
        Matcher m9 = p9.matcher(s);
        if (m9.find()) {
            String num = m9.group(1);
            sum = sum + Long.valueOf(num) * 10;
            //System.out.println(num + "十");
        }
        
        //Pattern p91 = Pattern.compile("(\\d+)(\\.\\d+)?拾");
        Matcher m91 = p91.matcher(s);
        if (m91.find()) {
            String num = m91.group(1);
            sum = sum + Long.valueOf(num) * 10;
            //System.out.println(num + "十");
        }
    }



    return sum.toString()+".00";
}

public static String method(String s) throws Exception {
    String test = "";
    // 是否全汉字
    if (s.matches("^[\\u4e00-\\u9fa5]+$")){
        return method1(s);
    }else{
        //调用方法二，方法二会判断是否符合b的条件，不符合就抛异常
        try {
            return method2(s);
        }catch (Exception e){
            return "请检查输入金额";
        }
    }
}

public static void main(String[] args) throws Exception {
    String a = "8千万5角6分";
    String method = method(a);
    System.out.println(method);
}
尘雨.
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值