BigDecimal你了解吗，遇到过哪些坑？

小熊学Java

于 2024-08-02 12:23:38 发布

阅读量312

点赞数 8

分类专栏：避坑指南全栈学习文章标签：开发语言避坑指南 java

本文链接：https://blog.csdn.net/Y_hanxiong/article/details/140869372

版权

全栈学习同时被 2 个专栏收录

57 篇文章 8 订阅

订阅专栏

避坑指南

6 篇文章 0 订阅

订阅专栏

BigDecimal 你遇到哪些坑？

BigDecimal 想必我们都不陌生，涉及到金额的地方基本上都是用这个数据类型进行处理，那一般你用的是哪个数据类型？精度是如何处理的？有没有碰到过坑？

1、BigDecimal 的概述

Java在java.math包中提供的API类BigDecimal，用来对超过16位有效位的数进行精确的运算。双精度浮点型变量double可以处理16位有效数，但在实际应用中，可能需要对更大或者更小的数进行运算和处理。一般情况下，对于那些不需要准确计算精度的数字，我们可以直接使用Float和Double处理，但是Double.valueOf(String) 和Float.valueOf(String)会丢失精度。所以开发中，如果我们需要精确计算的结果，则必须使用BigDecimal类来操作。

BigDecimal所创建的是对象故我们不能使用传统的＋，-,×，÷等算术运算符直接对其对象进行数学运算，而必须调用其相对应的方法。方法中的参数也必须是BigDecimal的对象。构造器是类的特殊方法，专门用来创建对象，特别是带有参数的对象。

更具体的用法请重学Java基础哈哈哈！

2、阿里巴巴开发规范

1、构造与比较

**【强制】**BigDecimal的等值比较应使用compareTo()方法，而不是equals()方法。

说明：equals()方法会比较值和精度（1.0与1.00返回结果为false），而compareTo()则会忽略精度

2、浮点数之间的判断

**【强制】**浮点数之间的等值判断，基本数据类型不能用==来比较，包装数据类型不能用equals来判断

说明：浮点数采用“尾数+阶码”的编码格式，似于科学计数法癿“有效数字+指数”的表示方式。二进制无法精确表示大部分的十进制小数，具体原理参考《码出高效》

反例：
float a = 1.0f - 0.9f; 
float b = 0.9f - 0.8f;
if (a == b) {
// 预期进入此代码块，执行其他逻辑
// 但事实上 a==b 的结果为 false
}
Float x = Float.valueOf(a); 
Float y = Float.valueOf(b); 
if (x.equals(y)) {
// 预期进入此代码块，执行其他逻辑
// 但事实上 equals 的结果为 false
}
正确的如下：
指定一个诨差范围，两个浮点数的差值在此范围之内，则认为是相等的。
float a = 1.0f - 0.9f;
float b = 0.9f - 0.8f;
float diff = 1e-6f;
if (Math.abs(a - b) < diff){ 
    System.out.println("true");
}
使用BigDecimal来定义值，再进行浮点数之间的运算
BigDecimal a = new BigDecimal("1.0"); 
BigDecimal b = new BigDecimal("0.9"); 
BigDecimal c = new BigDecimal("0.8");
BigDecimal x = a.subtract(b); 
BigDecimal y = b.subtract(c);
if (x.equals(y)) { 
    System.out.println("true");
}

11.【强制】禁止使用构造方法BigDecimal(double)的方式把double 值转化为BigDecimal 对象。

说明：BigDecimal(double)存在精度损失风险，在精确计算或值比较的场景中可能会导致业务逻辑异常。

如：BigDecimal g = new BigDecimal(0.1f); 实际的存储值为：0.10000000149

正例：优先推荐入参为 String 构造方法，或使用 BigDecimal 的valueOf 方法，此方法内部其实执行了

Double 的 toString，而 Double的toString 按 double 的实际能表达的精度对尾数迕行了截断。

BigDecimal recommend1 = new BigDecimal("0.1"); 
BigDecimal recommend2 = BigDecimal.valueOf(0.1);

3、案例分析

1、实体类与SQL

private BigDecimal amount;

2、分析

public class BigDecimal_BugDemo

{
    public static void main(String[] args)
    {
        //doubleDemo(); //double类型精度丢失

        //===================BigDecimal===================
        //m1();
        //m2();
        m3();
        //m4();
    }

    /**
     * 科学计数法相关
     *
     */
    private static void m4()
    {
        BigDecimal amount1 = BigDecimal.valueOf(1234567890123456789.3141592631415926);
        System.out.println(amount1);                    //科学计数法:    1.23456789012345677E+18
        System.out.println(amount1.toString());         //科学计数法:    1.23456789012345677E+18
        System.out.println(amount1.toPlainString());    //不使用科学计数法

        System.out.println();
        BigDecimal amount2 = new BigDecimal("1234567890123456789.3141592631415926");
        System.out.println(amount2);
        System.out.println(amount2.toString());
        System.out.println(amount2.toPlainString());

    }

    /**除法商的结果,需要指定精度
     * BigDecimal 的 8 种 RoundingMode（舍入模式）
     * https://my.oschina.net/u/3644969/blog/4927776
     *
     * ROUND_HALF_UP
     * 向 “最接近” 的数字舍入，如果与两个相邻数字的距离相等，则为向上舍入的舍入模式。
     * 如果舍弃部分 >= 0.5，则舍入行为与 ROUND_UP 相同；否则舍入行为与 ROUND_DOWN 相同。
     * 这种模式也就是我们常说的我们的 “四舍五入”。
     *
     * ROUND_HALF_DOWN
     *
     * 向 “最接近” 的数字舍入，如果与两个相邻数字的距离相等，则为向下舍入的舍入模式。
     * 如果舍弃部分 > 0.5，则舍入行为与 ROUND_UP 相同；否则舍入行为与 ROUND_DOWN 相同。
     * 这种模式也就是我们常说的我们的 “五舍六入”。
     */
    private static void m3()
    {
        BigDecimal amount1 = new BigDecimal("2.0");
        BigDecimal amount2 = new BigDecimal("3.0");
        //System.out.println(amount1.divide(amount2)); //Non-terminating decimal expansion; no exact representable decimal result.
        //我们该如何处理？
        System.out.println(amount1.divide(amount2, 2,RoundingMode.HALF_UP)); //这种模式也就是我们常说的我们的 “四舍五入”。
    }

    /**参考阿里手册
     * 10.【强制】BigDecimal的等值比较应使用compareTo() 方法，而不是equals() 方法。
     */
    private static void m2()
    {
        BigDecimal amount1 = new BigDecimal("0.9");
        BigDecimal amount2 = new BigDecimal("0.90");
        //给同学们看一下equals源码,它有个精度范围比较导致出错
        System.out.println("equals比较结果："+amount1.equals(amount2));
        System.out.println("compareTo比较结构："+amount1.compareTo(amount2));
    }

    /**
     * 参考阿里手册
     * 12.【强制】禁止使用构造方法BigDecimal(double) 的方式把double值转化为BigDecimal对象
     * 优先推荐入参为String的构造方法，或使用BigDecimal的valueOf方法，此方法内部其实执行了Double的
     * toString，而Double的toString按double的实际能表达的精度对尾数进行了截断。
     */
    private static void m1()
    {
        //给同学们看一下new BigDecimal()源码
        BigDecimal amount1 = new BigDecimal(0.03);
        BigDecimal amount2 = new BigDecimal(0.02);
        //12.【强制】禁止使用构造方法BigDecimal(double) 的方式把double值转化为BigDecimal对象,非要转那？
        System.out.println("amount1: "+amount1);
        System.out.println("amount2: "+amount2);
        //应该等于0.01
        System.out.println(amount1.subtract(amount2));
        System.out.println();
        //优先推荐入参为String的构造方法
        BigDecimal amount3 = new BigDecimal("0.03");
        BigDecimal amount4 = new BigDecimal("0.02");
        //应该等于0.01
        System.out.println(amount3.subtract(amount4));
        System.out.println();

        //使用BigDecimal的valueOf方法,给同学们看一下valueOf源码
        BigDecimal amount5 = BigDecimal.valueOf(0.03);
        BigDecimal amount6 = BigDecimal.valueOf(0.02);
        //应该等于0.01
        System.out.println(amount5.subtract(amount6));
    }


    /**
     * why
     * double类型的两个参数相减会转换成二进制，
     * 因为double有效位数为16位这就会出现存储小数位数不够的情况，这种情况下就会出现误差
     */
    private static void doubleDemo()
    {
        double amount1 = 0.03;
        double amount2 = 0.02;
        //执行结果会是多少？
        System.out.println(amount1 - amount2);

    }
}

m1()方法的结果如下：

amount1: 0.0299999999999999988897769753748434595763683319091796875
amount2: 0.0200000000000000004163336342344337026588618755340576171875
0.0099999999999999984734433411404097569175064563751220703125

0.01

0.01

m2()方法的结果如下：

equals比较结果：false
compareTo比较结构：0

m3()方法的结果如下：

0.67

m4()方法的结果如下：

1.2345678901234568E+18
1.2345678901234568E+18
1234567890123456800

1234567890123456789.3141592631415926
1234567890123456789.3141592631415926
1234567890123456789.3141592631415926

总结：

当使用Float/Double这些浮点数据时，会丢失精度，String/int类型就不会，BigDecimal(double)存在精度损失风险
等值比较应使用compareTo()方法，equals()方法会比较值和精度（1.0与1.00返回结果为false），而compareTo()则会忽略精度
除法商的结果需要指定精度
科学计数法的使用问题

4、编码最佳实践

public class ArithmeticUtils
{
    //默认除法运算精度
    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, BigDecimal.ROUND_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, BigDecimal.ROUND_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, BigDecimal.ROUND_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, BigDecimal.ROUND_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, BigDecimal.ROUND_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, BigDecimal.ROUND_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, BigDecimal.ROUND_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, BigDecimal.ROUND_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;
        if (bj > 0)
            res = true;
        else
            res = false;
        return res;
    }
}

小熊学Java

关注

8
点赞
踩
6

收藏

觉得还不错? 一键收藏
打赏
0
评论
BigDecimal你了解吗，遇到过哪些坑？

Java在java.math包中提供的API类BigDecimal，用来对超过16位有效位的数进行精确的运算。双精度浮点型变量double可以处理16位有效数，但在实际应用中，可能需要对更大或者更小的数进行运算和处理。一般情况下，对于那些不需要准确计算精度的数字，我们可以直接使用Float和Double处理，但是Double.valueOf(String) 和Float.valueOf(String)会丢失精度。所以开发中，如果我们需要精确计算的结果，则必须使用BigDecimal类来操作。
复制链接

扫一扫