工具类篇-02-BigDecimal工具类(包含金额大小写转换)

已于 2024-03-13 11:44:03 修改
阅读量2k 收藏 2
点赞数 1
文章标签： idea java
于 2021-09-28 13:43:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Hmj050117/article/details/120527497
版权

文章目录

1. 常见错误使用导致问题

案例：

BigDecimal a =new BigDecimal(0.1);
System.out.println("a values is:"+a);
System.out.println("=====================");
BigDecimal b =new BigDecimal("0.1");
System.out.println("b values is:"+b);

结果：

a values is:0.1000000000000000055511151231257827021181583404541015625
=====================
b values is:0.1

原因分析：

  • 参数类型为double的构造方法的结果有一定的不可预知性。有人可能认为在Java中写入newBigDecimal(0.1)所创建的BigDecimal正好等于 0.1（非标度值 1，其标度为 1），但是它实际上等于0.1000000000000000055511151231257827021181583404541015625。这是因为0.1无法准确地表示为 double（或者说对于该情况，不能表示为任何有限长度的二进制小数）。这样，传入到构造方法的值不会正好等于 0.1（虽然表面上等于该值）。

  • String 构造方法是完全可预知的：写入 newBigDecimal(“0.1”) 将创建一个 BigDecimal，它正好等于预期的 0.1。因此，比较而言， 通常建议优先使用String构造方法。

  • 当double必须用作BigDecimal的源时，请注意，此构造方法提供了一个准确转换；它不提供与以下操作相同的结果：先使用Double.toString(double)方法，然后使用BigDecimal(String)构造方法，将double转换为String。要获取该结果，请使用static valueOf(double)方法。

2 常见异常

  • 除法的时候出现异常
    java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result
    原因分析：
    通过BigDecimal的divide方法进行除法时当不整除，出现无限循环小数时，就会抛异常：java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result.
    解决方法：
    divide方法设置精确的小数点，如：divide(xxxxx,2)

3 BigDecimal总结

在需要精确的小数计算时再使用BigDecimal，BigDecimal的性能比double和float差，在处理庞大，复杂的运算时尤为明显。故一般精度的计算没必要使用BigDecimal。 尽量使用参数类型为String的构造函数。

BigDecimal都是不可变的（immutable）的， 在进行每一次四则运算时，都会产生一个新的对象 ，所以在做加减乘除运算时要记得要保存操作后的值。

4 封装的工具类

package com.ddmc.awaken.enums;

import java.math.BigDecimal;
import java.math.RoundingMode;

/**
 * 金额工具类
 *
 * @author Wang
 */
public class BigDecimalUtils {

    /**
     * 将数字BigDecimal转换成中文大写
     *
     * @param bigDecimal 原始的金额 eg：11111.11
     * @return 中文金额 eg: 壹万壹仟壹佰壹拾壹元壹角壹分
     */
    public static String bigDecimalToString(BigDecimal bigDecimal) {
        String[] chinese = new String[]{"", "拾", "佰", "仟", "万", "拾", "佰", "仟", "亿", "拾", "佰", "仟", "万"};
        String[] numChinese = new String[]{"零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"};
        String[] afterChinese = new String[]{"角", "分"};
        String str = String.valueOf(bigDecimal);
        String[] arr = str.split("\\.");
        char[] chars = arr[0].toCharArray();
        StringBuilder builder = new StringBuilder();

        for (int i = 0; i < chars.length; ++i) {
            builder.append(numChinese[Integer.parseInt(String.valueOf(chars[i]))]).append(chinese[chars.length - i - 1]);
        }

        if (arr.length == 1) {
            return builder.toString() + "元整";
        } else if (arr[1].length() > 2) {
            throw new IllegalArgumentException("人民币大写转换BigDecimal只能保留2位小数");
        } else {
            builder.append("元");
            char[] chars1 = arr[1].toCharArray();

            for (int i = 0; i < chars1.length; ++i) {
                builder.append(numChinese[Integer.parseInt(String.valueOf(chars1[i]))]).append(afterChinese[i]);
            }

            return builder.toString();
        }
    }


    private static final String UNIT = "万仟佰拾亿仟佰拾万仟佰拾元角分";
    private static final String DIGIT = "零壹贰叁肆伍陆柒捌玖";
    private static final double MAX_VALUE = 9999999999999.99D;

    /**
     * 将数字BigDecimal转换成中文大写
     *
     * @param bigDecimal 原始的金额 eg：11111.11
     * @return 中文金额 eg: 壹万壹仟壹佰壹拾壹元壹角壹分
     */
    public static String bigDecimalToString2(BigDecimal bigDecimal) {

        double v = bigDecimal.doubleValue();

        if (v < 0 || v > MAX_VALUE) {
            return "参数非法!";
        }
        long l = Math.round(v * 100);
        if (l == 0) {
            return "零元整";
        }
        String strValue = l + "";
        // i用来控制数
        int i = 0;
        // j用来控制单位
        int j = UNIT.length() - strValue.length();
        StringBuilder rs = new StringBuilder();
        boolean isZero = false;
        for (; i < strValue.length(); i++, j++) {
            char ch = strValue.charAt(i);
            if (ch == '0') {
                isZero = true;
                if (UNIT.charAt(j) == '亿' || UNIT.charAt(j) == '万' || UNIT.charAt(j) == '元') {
                    rs.append(UNIT.charAt(j));
                    isZero = false;
                }
            } else {
                if (isZero) {
                    rs.append("零");
                    isZero = false;
                }
                rs.append(DIGIT.charAt(ch - '0')).append(UNIT.charAt(j));
            }
        }
        if (!rs.toString().endsWith("分") && !rs.toString().endsWith("角")) {
            rs.append("整");
        }
        rs = new StringBuilder(rs.toString().replaceAll("亿万", "亿"));
        return rs.toString();
    }


    //默认除法运算精度
    private static final int DEF_DIV_SCALE = 10;

    /**
     * 提供精确的加法运算
     *
     * @param v1 被加数
     * @param v2 加数
     * @return 两个参数的和
     */

    public static double add(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.add(b2).doubleValue();
    }

    /**
     * 提供精确的加法运算
     *
     * @param v1 被加数
     * @param v2 加数
     * @return 两个参数的和
     */
    public static BigDecimal add(String v1, String v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.add(b2);
    }

    /**
     * 提供精确的加法运算
     *
     * @param v1    被加数
     * @param v2    加数
     * @param scale 保留scale 位小数
     * @return 两个参数的和
     */
    public static String add(String v1, String v2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.add(b2).setScale(scale, RoundingMode.HALF_UP).toString();
    }

    /**
     * 提供精确的减法运算
     *
     * @param v1 被减数
     * @param v2 减数
     * @return 两个参数的差
     */
    public static double sub(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.subtract(b2).doubleValue();
    }

    /**
     * 提供精确的减法运算。
     *
     * @param v1 被减数
     * @param v2 减数
     * @return 两个参数的差
     */
    public static BigDecimal sub(String v1, String v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.subtract(b2);
    }

    /**
     * 提供精确的减法运算
     *
     * @param v1    被减数
     * @param v2    减数
     * @param scale 保留scale 位小数
     * @return 两个参数的差
     */
    public static String sub(String v1, String v2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.subtract(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
    }

    /**
     * 提供精确的乘法运算
     *
     * @param v1 被乘数
     * @param v2 乘数
     * @return 两个参数的积
     */
    public static double mul(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.multiply(b2).doubleValue();
    }

    /**
     * 提供精确的乘法运算
     *
     * @param v1 被乘数
     * @param v2 乘数
     * @return 两个参数的积
     */
    public static BigDecimal mul(String v1, String v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.multiply(b2);
    }

    /**
     * 提供精确的乘法运算
     *
     * @param v1    被乘数
     * @param v2    乘数
     * @param scale 保留scale 位小数
     * @return 两个参数的积
     */
    public static double mul(double v1, double v2, int scale) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return round(b1.multiply(b2).doubleValue(), scale);
    }

    /**
     * 提供精确的乘法运算
     *
     * @param v1    被乘数
     * @param v2    乘数
     * @param scale 保留scale 位小数
     * @return 两个参数的积
     */
    public static String mul(String v1, String v2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.multiply(b2).setScale(scale, RoundingMode.HALF_UP).toString();
    }

    /**
     * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到
     * 小数点以后10位，以后的数字四舍五入
     *
     * @param v1 被除数
     * @param v2 除数
     * @return 两个参数的商
     */

    public static double div(double v1, double v2) {
        return div(v1, v2, DEF_DIV_SCALE);
    }

    /**
     * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
     * 定精度，以后的数字四舍五入
     *
     * @param v1    被除数
     * @param v2    除数
     * @param scale 表示表示需要精确到小数点以后几位。
     * @return 两个参数的商
     */
    public static double div(double v1, double v2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException("The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.divide(b2, scale, RoundingMode.HALF_UP).doubleValue();
    }

    /**
     * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
     * 定精度，以后的数字四舍五入
     *
     * @param v1    被除数
     * @param v2    除数
     * @param scale 表示需要精确到小数点以后几位
     * @return 两个参数的商
     */
    public static String div(String v1, String v2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException("The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v1);
        return b1.divide(b2, scale, RoundingMode.HALF_UP).toString();
    }

    /**
     * 提供精确的小数位四舍五入处理
     *
     * @param v     需要四舍五入的数字
     * @param scale 小数点后保留几位
     * @return 四舍五入后的结果
     */
    public static double round(double v, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException("The scale must be a positive integer or zero");
        }
        BigDecimal b = new BigDecimal(Double.toString(v));
        return b.setScale(scale, RoundingMode.HALF_UP).doubleValue();
    }

    /**
     * 提供精确的小数位四舍五入处理
     *
     * @param v     需要四舍五入的数字
     * @param scale 小数点后保留几位
     * @return 四舍五入后的结果
     */
    public static String round(String v, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        BigDecimal b = new BigDecimal(v);
        return b.setScale(scale, RoundingMode.HALF_UP).toString();
    }

    /**
     * 取余数
     *
     * @param v1    被除数
     * @param v2    除数
     * @param scale 小数点后保留几位
     * @return 余数
     */
    public static String remainder(String v1, String v2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        return b1.remainder(b2).setScale(scale, RoundingMode.HALF_UP).toString();
    }

    /**
     * 取余数  BigDecimal
     *
     * @param v1    被除数
     * @param v2    除数
     * @param scale 小数点后保留几位
     * @return 余数
     */
    public static BigDecimal remainder(BigDecimal v1, BigDecimal v2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException(
                    "The scale must be a positive integer or zero");
        }
        return v1.remainder(v2).setScale(scale, RoundingMode.HALF_UP);
    }

    /**
     * 比较大小
     *
     * @param v1 被比较数
     * @param v2 比较数
     * @return 如果v1 大于v2 则 返回true 否则false
     */
    public static boolean compare(String v1, String v2) {
        BigDecimal b1 = new BigDecimal(v1);
        BigDecimal b2 = new BigDecimal(v2);
        int bj = b1.compareTo(b2);
        boolean res;
        res = bj > 0;
        return res;
    }
}
Alan0517
关注
专栏目录
Android查看文件夹大小以及删除文件夹的工具类
01-20
那我们需要获取文件之后需要对文件进行删除等操作，下面是写的一个工具类，用于查看文件夹大小以及删除文件夹。 import android.text.TextUtils; import java.io.File; import java.math.BigDecimal; public class ...
BigDecimal高精度运算
最新发布
cyt涛的博客
08-14 896
当两个整数进行除法运算时，直接相除会丢弃小数部分，得到一个整数结果。然而，通过使用BigDecimal类或工具类方法（如 Hutool 的），可以保留小数部分并得到一个精确的BigDecimal结果。这种方法特别适用于需要高精度计算的场景，例如财务、科学计算等。
java算小数,java 小数运算 - osc_popfjd1t的个人空间 - OSCHINA - 中文开源技术交流社区...
weixin_33245735的博客
03-22 240
packagecom.chobits81.cc.utils;importjava.math.BigDecimal;public classMathUtil {public static voidmain(String[] args) {/*String a="1234567891234567891234788778875555555.5678912345678912123456789";Strin...
BigDecimal 工具类
yangziqi098的博客
06-09 328
BigDecimal 工具类
Java之BigDecimal详解
weixin_43102784的博客
06-07 1580
在需要精确的小数计算时再使用BigDecimal，BigDecimal的性能比double和float差，在处理庞大，复杂的运算时尤为明显。故一般精度的计算没必要使用BigDecimal。尽量使用参数类型为String的构造函数。BigDecimal都是不可变的（immutable）的， 在进行每一次四则运算时，都会产生一个新的对象 ，所以在做加减乘除运算时要记得要保存操作后的值。
Java中熟练掌握BigDecimal运用-工具类
qq_30713721的博客
12-04 758
浮点数值不适用于无法接受舍入误差的计算当中，比如金融计算，所以建议用BigDecimal计算金额问题。 背景：有些人对BigDecimal接触很少、用得少，对常见的乘法、除法计算有问题，所以封装一下方便高效运用，减少不必要的bug处理时间。
Java实用经验总结--日期、数字篇
08-31
注意，日期格式的字母大小写是有意义的，"yyyy" 表示四位数的年份，而 "YYYY" 通常用于星期的年份，所以在格式化时应使用 "yyyy-MM-dd" 而非 "YYYY-MM-DD"。 2. **日期差计算** - 由于 `java.util.Date` 的 `...
web报表开发工具FineReport常用函数的用法总结（文本函数
05-11
`EXACT(text1, text2)` 函数用于检测两个文本字符串是否完全相同，包括大小写的区别。 **参数说明：** - `text1`：需要比较的第一个文本。 - `text2`：需要比较的第二个文本。 **示例：** - `EXACT("Spreadsheet",...
java编程-API教程
04-16
- equals()：比较的是字符串内容是否相等，忽略大小写和类型差异。 总结，Java API是Java编程的基础，理解和熟练使用API能大大提高开发效率。学习API时，不仅要掌握各个类和方法的功能，还要注意其使用场景和注意...
Java Bigdecimal类型 转 中文大写金额 工具类
qq_36527503的博客
11-16 658
private static final String[] UNIT = {"", "拾", "佰", "仟", "万", "拾万", "佰万", "仟万", "亿", "拾亿", "佰亿", "仟亿"};private static final String[] NUM = {"零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"};// 如果小数位不为0才添加单位。//如果小数部分不为00才进行转换。//如果小数部分为00加整。* 类说明:数字转汉字钱。
java BigDecimal金额转中文大写
qq_43470725的博客
05-09 833
java
Java 将数字转换为大写金额
输微
08-05 1077
在网上搜了半天，发现知乎的这篇回答里面的代码写的不错。1.整数部分和小数部分都可能会有多余的“零”于是对代码进行了重写，测试了一下应该没有问题。2.没法根据参数 动态处理多余的小数。但是这个回答里面的代码存在两个问题。
精确的数据类型BigDecimal和工具类
qq_46724069的博客
12-08 898
位有效位的数进行精确的运算，因为在现实生活中，财务、超市、银行使用基本的数据类型浮点数的时候只满足。定义了很多的有参构造函数，十分的丰富，省略了无参构造。类，实现了比较器的接口，用来对超过。时候，输出结果不可预知，因为。的构造器是可预知的，是准确的。无法准确的表示有限长度的。位就会出现精度上的丢失。的构造器中传入浮点数。
BigDecimal工具类
weixin_42326851的博客
03-27 2080
用于高精确处理常用的数学运算如果此篇文章有帮助到您, 希望打大佬们能关注评论如果有不对的地方请指正!!!参考1。
大数据BigDecimal工具类
大白猫的博客
11-11 1195
我们在开发中经常要对数据进行运算，获取对应正确的数值，而double和float这两个本质都是小数点，没办法使用二进制精确的表示，所以他们是不准确的，这个时候就应该使用大数据BigDecimal进行运算了，它可以精确的算出想要的结果。这样就可以实现开发者数据的计算了。
Android 精确浮点数运算工具类
1. `strPreDou(String v)`：将字符串转换为精确的double类型，通过`BigDecimal`类确保转换的准确性，避免了浮点数运算带来的精度损失。 2. `add(double v1, double v2)` 和 `sub(double v1, double v2)`：提供精确...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Alan0517

感谢您的鼓励与支持！

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值