利用BigDecimal类巧妙处理Double类型精度丢失

最新推荐文章于 2024-07-29 14:22:26 发布
最新推荐文章于 2024-07-29 14:22:26 发布
阅读量1.8k 收藏 6
点赞数
分类专栏： 后端 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51620667/article/details/126885771
版权

文章目录

浮点数精度丢失

精度丢失的问题是在其他计算机语言中也都会出现，float和double类型的数据在执行二进制浮点运算的时候，并没有提供完全精确的结果。产生误差不在于数的大小，而是因为数的精度。

如何用BigDecimal解决double精度问题？

我们已经明白为什么精度会存在丢失现象，那么我们就应该知道，当某个业务场景对double数据的精度要求非常高时，就必须采取某种手段来处理这个问题，这也是BigDecimal为什么会被广泛应用于金额支付场景中的原因啦。

BigDecimal类位于java.math包下，用于对超过16位有效位的数进行精确的运算。一般来说，double类型的变量可以处理16位有效数，但实际应用中，如果超过16位，就需要BigDecimal类来操作。

But

public static void main(String[] args) {
		// 方法1
        BigDecimal a = new BigDecimal(0.1);
        System.out.println("a --> " + a);
		// 方法2
        BigDecimal b = new BigDecimal("0.1");
        System.out.println("b --> " + b);
		// 方法3
        BigDecimal c = BigDecimal.valueOf(0.1);
        System.out.println("c --> " + c);
    }

控制台却输出

a --> 0.1000000000000000055511151231257827021181583404541015625
b --> 0.1
c --> 0.1

可以看到，使用方法一的构造函数仍然出现了精度丢失的问题，而方法二和方法三符合我们的预期，为什么会这样呢？

这三个方法其实对应着三种不同的构造函数：

public BigDecimal(double val) {
        this(val,MathContext.UNLIMITED);
    }

public BigDecimal(String val) {
        this(val.toCharArray(), 0, val.length());
    }

public static BigDecimal valueOf(double val) {
        // Reminder: a zero double returns '0.0', so we cannot fastpath
        // to use the constant ZERO.  This might be important enough to
        // justify a factory approach, a cache, or a few private
        // constants, later.
        return new BigDecimal(Double.toString(val)); // 可以看出其实第三种实际上就是第二种的封装
    }

关于这三个构造函数，JDK已经给出了解释，并用Notes标注：

image-20220916102421950

BigDecimal工具类进行运算，示例：

​ 转换为BigDecimal对象之后再进行加减乘除操作，这样精度就不会出现问题了。这也是为什么有关金钱数据存储都使用BigDecimal。

​ 处理double类型数据的加、减、乘、除运算时，使用如下方法：

import java.math.BigDecimal;
 
public class BigDecimalUtil {
 
    /**
     * 加法运算
     * @param m1
     * @param m2
     * @return  不加doubleValue()则, 返回BigDecimal对象
     */
    public static double addDouble(double m1, double m2) {
        BigDecimal p1 = new BigDecimal(Double.toString(m1));
        BigDecimal p2 = new BigDecimal(Double.toString(m2));
        return p1.add(p2).doubleValue();
    }
 
    /**
     * 减法运算
     * @param m1
     * @param m2
     * @return  不加doubleValue()则, 返回BigDecimal对象
     */
    public static double subDouble(double m1, double m2) {
        BigDecimal p1 = new BigDecimal(Double.toString(m1));
        BigDecimal p2 = new BigDecimal(Double.toString(m2));
        return p1.subtract(p2).doubleValue();
    }
 
    /**
     * 乘法运算
     * @param m1
     * @param m2
     * @return  不加doubleValue()则, 返回BigDecimal对象
     */
    public static double mul(double m1, double m2) {
        BigDecimal p1 = new BigDecimal(Double.toString(m1));
        BigDecimal p2 = new BigDecimal(Double.toString(m2));
        return p1.multiply(p2).doubleValue();
    }
 
    /**
     * 除法运算
     * @param   m1
     * @param   m2
     * @param   scale
     * @return  不加doubleValue()则, 返回BigDecimal对象
     */
    public static double div(double m1, double m2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException("Parameter error");
        }
        BigDecimal p1 = new BigDecimal(Double.toString(m1));
        BigDecimal p2 = new BigDecimal(Double.toString(m2));
        return p1.divide(p2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
    }
}

Double的加减乘除运算工具类2

​ BigDecimal所创建的是对象，故我们不能使用传统的+、-、*、/等算术运算符直接对其对象进行数学运算，而必须调用其相对应的方法。

​ 方法中的参数也必须是BigDecimal的对象。

​ 网上有很多这样的工具类，这边直接贴一下，逻辑不难，主要为了简化项目中频繁互相转化的问题。

import java.math.BigDecimal;

/**
 * * 用于高精确处理常用的数学运算
 * <p>
 */

public class ArithmeticUtils {

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


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


    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();

    }


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


    public static BigDecimal add(String v1, String v2) {

        BigDecimal b1 = new BigDecimal(v1);

        BigDecimal b2 = new BigDecimal(v2);

        return b1.add(b2);

    }


    /**
     * * 提供精确的加法运算
     * <p>
     * *
     * <p>
     * * @param v1 被加数
     * <p>
     * * @param v2 加数
     * <p>
     * * @param scale 保留scale 位小数
     * <p>
     * * @return 两个参数的和
     * <p>
     */


    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();

    }


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


    public static double div(double v1, double v2) {

        return div(v1, v2, DEF_DIV_SCALE);

    }


    /**
     * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
     * <p>
     * 定精度，以后的数字四舍五入
     *
     * @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参数指
     * <p>
     * 定精度，以后的数字四舍五入
     *
     * @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);

    }


    /**
     * 比较大小
     * <p>
     * 阿里巴巴开发规范明确：比较BigDecimal的等值需要使用compareTo，不可用equals
     * <p>
     * equals会比较值和精度，compareTo会忽略精度
     *
     * @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开发手册关于BigDecimal的规定

【强制】如上所示BigDecimal的等值比较应使用compareTo()方法，而不是equals()方法。 说明：equals()方法会比较值和精度(1.0和1.00返回结果为false),而compareTo()则会忽略精度。

关于这一点，我们来看一个例子就明白了：

public static void main(String[] args) {
        BigDecimal a = new BigDecimal("1");
        BigDecimal b = new BigDecimal("1.0");
        System.out.println(a.equals(b)); // false
        System.out.println(a.compareTo(b)); //0 表示相等
    }

JDK中对这两个方法的解释是这样的：

  • 使用compareTo方法，两个值相等但是精度不同的BigDecimal对象会被认为是相等的，比如2.0和2.00。建议使用x.compareTo(y) 0来表示(<, == , > , >= , != , <=)中的其中一个关系，就表示运算符。
  • equals方法与compareTo方法不同，此方法仅在两个BigDecimal对象的值和精度都相等时才被认为是相等的，如2.0和2.00就是不相等的。

的等值比较应使用compareTo()方法，而不是equals()方法。 说明：equals()方法会比较值和精度(1.0和1.00返回结果为false),而compareTo()则会忽略精度。

关于这一点，我们来看一个例子就明白了：

public static void main(String[] args) {
        BigDecimal a = new BigDecimal("1");
        BigDecimal b = new BigDecimal("1.0");
        System.out.println(a.equals(b)); // false
        System.out.println(a.compareTo(b)); //0 表示相等
    }

JDK中对这两个方法的解释是这样的：

  • 使用compareTo方法，两个值相等但是精度不同的BigDecimal对象会被认为是相等的，比如2.0和2.00。建议使用x.compareTo(y) 0来表示(<, == , > , >= , != , <=)中的其中一个关系，就表示运算符。
  • equals方法与compareTo方法不同，此方法仅在两个BigDecimal对象的值和精度都相等时才被认为是相等的，如2.0和2.00就是不相等的。
oah1021
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java：利用BigDecimal类巧妙处理Double类型精度丢失
Java圈全能架构师的博客
12-29 392
本篇要点 简单描述浮点数十进制转二进制精度丢失的原因。 介绍几种创建BigDecimal方式的区别。 整理了高精度计算的工具类。 学习了阿里巴巴Java开发手册关于BigDecimal比较相等的规定。 经典问题：浮点数精度丢失 精度丢失的问题是在其他计算机语言中也都会出现，float和double类型的数据在执行二进制浮点运算的时候，并没有提供完全精确的结果。产生误差不在于数的大小，而是因为数的精度。 关于浮点数存储精度丢失的问题，话题过于庞大，感兴趣的同学可以自行搜索一下 这里简单讨论一下十
BigDecimal使用及Double运算精度丢失问题处理
Jamesfeiyue的博客
06-02 957
BigDecimal使用及Double运算精度丢失问题处理 BigDecimal使用（优点：可保持计算精度） 1.创建 BigDecimal b1 = new BigDecimal("9.2");//9.2 BigDecimal b2 = BigDecimal.valueOf(9.2);//9.2 2.运算（不是对原值进行操作，而是生成新的对象） public BigDecimal add(BigDecimal value);//加法 public BigDecimal subtract(BigDecim
Java中BigDecimal对象与double之间转换涉及的精度问题及“no exact representable decimal result.”解决方案
weixin_42386014的博客
03-05 2391
当我们在开发的时候，有时候根据需求来讲，会要求小数点后精确到几位数，例如涉及到费用的问题，通常会让我们精确到小数点后4位，就类似于“0.3333”的格式，当我们在想要进行精确到小数点后几位时，这时候就会想到BigDeimal对象来进行转化，不过在进行转化的过程中，笔者遇见了几个不小的“坑”。 1.BigDecimal的构造方法 我们来看看JDK1.8中对BigDecimal对象是如何解释他的构...
BigDecimal(double)存在精度损失风险
罗格的博客
08-10 2452
说明：BigDecimal(double)存在精度损失风险，在精确计算或值比较的场景中可能会导致业务逻辑异常。 如： BigDecimal g = new BigDecimal(0.1f); 实际的存储值为：0.10000000149 正例：优先推荐入参为 String 的构造方法，或使用 BigDecimal 的 valueOf 方法，此方法内部其实执行了 Double 的 toString，而 Double 的 toString 按 double 的实际能表达的精度对尾数进行了截断。
Java 将 BigDecimal 类型的值转成 double 类型
良月柒
05-21 870
在 Java 中，BigDecimal可以转换为double类型，但需要注意的是，这样的转换可能会导致精度损失，因为BigDecimal的精度比double高很多。这里是将BigDecimal转换为double。
使用BigDecimal字符转换的精度丢失问题
舜意的博客
11-07 728
对于使用BigDecimal字符转换的精度丢失问题
探索BigDecimal和Double区别，更适合在什么条件下使用？
weixin_43267639的博客
05-17 2946
探索BigDecimal和Double区别，更适合在什么条件下使用？
BigDecimal和double类型相互转换，一行搞定
热门推荐
angang12的博客
09-10 5万+
BigDecimal类型和double类型的值相互转换 1.BigDecimal转double，使用BigDecimal类里面doubleValue()方法： BigDecimal latitude = 39.97268600; double latitudeDou = latitude.doubleValue() 2.double转BigDecimal，使用BigDecimal类里面valueOf()方法： double latitudeDou = 39.97268600; BigDecimal lat
Java中BigDecimal类的使用详解
08-18
在使用BigDecimal类时，我们需要将Double类型的数据转换为BigDecimal对象。可以使用以下方法实现： Double num = 123456789.98; BigDecimal bg2=new BigDecimal(num + ""); 这样，我们可以将Double类型的数据转换...
Java BigDecimal和double示例及相关问题解析
08-28
在 Java 中，浮点数的表示形式有多种，包括 float 和 double 等，但是这些类型在进行计算时会出现精度问题，而 BigDecimal 则可以解决这种问题。本文将主要介绍 Java 中的 BigDecimal 和 double 的示例及相关问题...
java中double转化为BigDecimal精度缺失的实例
08-31
在Java编程语言中，数值类型如`double`和`float`虽然方便进行浮点数运算，但它们在处理精度上存在一定的局限性。这主要是由于它们是基于二进制浮点数表示法，而非十进制。在进行计算时，某些十进制小数无法精确地...
解决java数值范围以及float与double精度丢失的问题
08-30
解决java数值范围以及float与double精度丢失的问题 Java中的数值范围和浮点数精度问题是许多开发者经常遇到的问题。下面我们将详细探讨Java中的数值范围、float和double类型的精度问题，并且提供解决方案。 一、...
Java用BigDecimal解决double类型相减时可能存在的误差
08-19
在Java编程语言中，`double`类型用于表示浮点数，但存在精度问题，尤其是在进行数学运算时。这是因为`double`是基于二进制浮点数标准（IEEE 754）来存储和计算的，这可能导致计算结果与预期的十进制值存在微小的差异...
Double为什么会丢失精度？
u011277123的博客
07-13 3万+
斯蒂芬朱cPlusPlus2019-07-12 09:20:00 前言：在工作中，谈到有小数点的加减乘除都会想到用BigDecimal来解决，但是有很多人对于double或者float为啥会丢失精度一脸茫然。还有BigDecimal是怎么解决的？话不多说，我们开始。 1.浮点数是啥？ 浮点数是计算机用来表示小数的一种数据类型，采用科学计数法。 在java中，double是双精度，64位，...
BigDecimal和Double的区别
monicateacat的博客
01-28 1740
精确性：由于计算机内部使用二进制表示浮点数，而十进制小数无法精确表示为二进制，因此在进行浮点数计算时，Double会存在舍入误差。精度：BigDecimal是高精度的十进制表示，它可以表示任意精度的小数。相比之下，Double是双精度浮点数，它的精度有限，只能表示有限位数的小数。大小范围：Double的取值范围较大，可以表示较小的负数和较大的正数。运算：Double类型的数值可以直接进行加减乘除等基本运算，而BigDecimal需要使用其提供的方法进行运算，例如。
double会丢失精度，Bigdecimal就一定安全吗
楼兰过客的博客
02-01 1009
在处理精确数值计算时，BigDecimal是Java中一个强大的工具，但在使用过程中需要注意一些潜在的问题。避免使用浮点数构造BigDecimal，而是使用String类型的构造器，在进行除法运算时一定要指定舍入模式，谨慎指定舍入模式，使用compareTo比较BigDecimal的值，要使用BigDecimal进行高精度的运算。
Java BigDecimal 与 java的四舍五入 详解
liujian928730的专栏
01-19 7168
1.引言         借用《Effactive Java》这本书中的话，float和double类型的主要设计目标是为了科学计算和工程计算。他们执行二进制浮点运算，这是为了在广域数值范围上提供较为精确的快速近似计算而精心设计的。然而，它们没有提供完全精确的结果，所以不应该被用于要求精确结果的场合。但是，商业计算往往要求结果精确，这时候BigDecimal就派上大用场啦。   2.Bi
BigDecimal常用方法
qq_44691484的博客
11-27 274
add(BigDecimal) BigDecimal对象中的值相加，返回BigDecimal对象 subtract(BigDecimal) BigDecimal对象中的值相减，返回BigDecimal对象 multiply(BigDecimal) BigDecimal对象中的值相乘，返回BigDecimal对象 divide(BigDecimal) BigDecimal对象中的值相除，返回BigDecimal对象 toString() 将BigDecimal对象中的值转换成字符串 doubleValue()
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
最新发布
qq_43700885的博客
07-29 515
1.导入hutool的maven依赖。2.复制一下代码执行。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

oah1021

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值