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

快来打我* 2024-03-27 19:00 217阅读 0赞

本篇要点

  • 简单描述浮点数十进制转二进制精度丢失的原因。
  • 介绍几种创建BigDecimal方式的区别。
  • 整理了高精度计算的工具类。
  • 学习了阿里巴巴Java开发手册关于BigDecimal比较相等的规定。

经典问题：浮点数精度丢失

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

关于浮点数存储精度丢失的问题，话题过于庞大，感兴趣的同学可以自行搜索一下：【解惑】剖析float型的内存存储和精度丢失问题

这里简单讨论一下十进制数转二进制为什么会出现精度丢失的现象，十进制数分为整数部分和小数部分，我们分开来看看就知道原因为何：

十进制整数如何转化为二进制整数？

将被除数每次都除以2，只要除到商为0就可以停止这个过程。

  1. 5 / 2 = 2 余 1
  2. 2 / 2 = 1 余 0
  3. 1 / 2 = 0 余 1 
  5. // 结果为 101

这个算法永远都不会无限循环，整数永远都可以使用二进制数精确表示，但小数呢？

十进制小数如何转化为二进制数？

每次将小数部分乘2，取出整数部分，如果小数部分为0，就可以停止这个过程。

  1. 0.1 * 2 = 0.2 取整数部分0
  2. 0.2 * 2 = 0.4 取整数部分0
  3. 0.4 * 2 = 0.8 取整数部分0
  4. 0.8 * 2 = 1.6 取整数部分1
  5. 0.6 * 2 = 1.2 取整数部分1
  6. 0.2 * 2 = 0.4 取整数部分0 
  8. //... 我想写到这就不必再写了，你应该也已经发现，上面的过程已经开始循环，小数部分永远不能为0

这个算法有一定概率会存在无限循环，即无法用有限长度的二进制数表示十进制的小数，这就是精度丢失问题产生的原因。

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

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

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

既然这样，那用BigDecimal就能够很好解决这个问题咯？

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

你可以思考一下，控制台输出会是啥。

  1. a --> 0.1000000000000000055511151231257827021181583404541015625
  2. b --> 0.1
  3. c --> 0.1

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

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

  1.     // 传入double
  2.  public BigDecimal(double val) {
  3.         this(val,MathContext.UNLIMITED);
  4.     }
  5.  // 传入string
  6.     public BigDecimal(String val) {
  7.         this(val.toCharArray(), 0, val.length());
  8.     }
  10.     public static BigDecimal valueOf(double val) {
  11.         // Reminder: a zero double returns '0.0', so we cannot fastpath
  12.         // to use the constant ZERO.  This might be important enough to
  13.         // justify a factory approach, a cache, or a few private
  14.         // constants, later.
  15.         // 可以看到实际上就是第二种
  16.         return new BigDecimal(Double.toString(val));
  17.     }

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

683476aed4eb4a1a93ab084b469ff94a.png

为了防止以后图片可能会存在显示问题，这里再记录一下：

new BigDecimal(double val)

该方法是不可预测的，以0.1为例，你以为你传了一个double类型的0.1，最后会返回一个值为0.1的BigDecimal吗？不会的，原因在于，0.1无法用有限长度的二进制数表示，无法精确地表示为双精度数，最后的结果会是0.100000xxx。

new BigDecimal(String val)

该方法是完全可预测的，也就是说你传入一个字符串”0.1”，他就会给你返回一个值完全为0，1的BigDecimal，官方也表示，能用这个构造函数就用这个构造函数叭。

BigDecimal.valueOf(double val)

第二种构造方式已经足够优秀，可你还是想传入一个double值，怎么办呢？官方其实提供给你思路并且实现了它，可以使用Double.toString(double val)先将double值转为String，再调用第二种构造方式，你可以直接使用静态方法：valueOf(double val)。

Double的加减乘除运算工具类

BigDecimal所创建的是对象，故我们不能使用传统的+、-、*、/等算术运算符直接对其对象进行数学运算，而必须调用其相对应的方法。方法中的参数也必须是BigDecimal的对象。网上有很多这样的工具类，这边直接贴一下，逻辑不难，主要为了简化项目中频繁互相转化的问题。

  1. /**
  2.  * 用于高精确处理常用的数学运算
  3.  */
  4. public class ArithmeticUtils {
  5.     //默认除法运算精度
  6.     private static final int DEF_DIV_SCALE = 10;
  8.     /**
  9.      * 提供精确的加法运算
  10.      *
  11.      * @param v1 被加数
  12.      * @param v2 加数
  13.      * @return 两个参数的和
  14.      */
  16.     public static double add(double v1, double v2) {
  17.         BigDecimal b1 = new BigDecimal(Double.toString(v1));
  18.         BigDecimal b2 = new BigDecimal(Double.toString(v2));
  19.         return b1.add(b2).doubleValue();
  20.     }
  22.     /**
  23.      * 提供精确的加法运算
  24.      *
  25.      * @param v1 被加数
  26.      * @param v2 加数
  27.      * @return 两个参数的和
  28.      */
  29.     public static BigDecimal add(String v1, String v2) {
  30.         BigDecimal b1 = new BigDecimal(v1);
  31.         BigDecimal b2 = new BigDecimal(v2);
  32.         return b1.add(b2);
  33.     }
  35.     /**
  36.      * 提供精确的加法运算
  37.      *
  38.      * @param v1    被加数
  39.      * @param v2    加数
  40.      * @param scale 保留scale 位小数
  41.      * @return 两个参数的和
  42.      */
  43.     public static String add(String v1, String v2, int scale) {
  44.         if (scale < 0) {
  45.             throw new IllegalArgumentException(
  46.                     "The scale must be a positive integer or zero");
  47.         }
  48.         BigDecimal b1 = new BigDecimal(v1);
  49.         BigDecimal b2 = new BigDecimal(v2);
  50.         return b1.add(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
  51.     }
  53.     /**
  54.      * 提供精确的减法运算
  55.      *
  56.      * @param v1 被减数
  57.      * @param v2 减数
  58.      * @return 两个参数的差
  59.      */
  60.     public static double sub(double v1, double v2) {
  61.         BigDecimal b1 = new BigDecimal(Double.toString(v1));
  62.         BigDecimal b2 = new BigDecimal(Double.toString(v2));
  63.         return b1.subtract(b2).doubleValue();
  64.     }
  66.     /**
  67.      * 提供精确的减法运算。
  68.      *
  69.      * @param v1 被减数
  70.      * @param v2 减数
  71.      * @return 两个参数的差
  72.      */
  73.     public static BigDecimal sub(String v1, String v2) {
  74.         BigDecimal b1 = new BigDecimal(v1);
  75.         BigDecimal b2 = new BigDecimal(v2);
  76.         return b1.subtract(b2);
  77.     }
  79.     /**
  80.      * 提供精确的减法运算
  81.      *
  82.      * @param v1    被减数
  83.      * @param v2    减数
  84.      * @param scale 保留scale 位小数
  85.      * @return 两个参数的差
  86.      */
  87.     public static String sub(String v1, String v2, int scale) {
  88.         if (scale < 0) {
  89.             throw new IllegalArgumentException(
  90.                     "The scale must be a positive integer or zero");
  91.         }
  92.         BigDecimal b1 = new BigDecimal(v1);
  93.         BigDecimal b2 = new BigDecimal(v2);
  94.         return b1.subtract(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
  95.     }
  97.     /**
  98.      * 提供精确的乘法运算
  99.      *
  100.      * @param v1 被乘数
  101.      * @param v2 乘数
  102.      * @return 两个参数的积
  103.      */
  104.     public static double mul(double v1, double v2) {
  105.         BigDecimal b1 = new BigDecimal(Double.toString(v1));
  106.         BigDecimal b2 = new BigDecimal(Double.toString(v2));
  107.         return b1.multiply(b2).doubleValue();
  108.     }
  110.     /**
  111.      * 提供精确的乘法运算
  112.      *
  113.      * @param v1 被乘数
  114.      * @param v2 乘数
  115.      * @return 两个参数的积
  116.      */
  117.     public static BigDecimal mul(String v1, String v2) {
  118.         BigDecimal b1 = new BigDecimal(v1);
  119.         BigDecimal b2 = new BigDecimal(v2);
  120.         return b1.multiply(b2);
  121.     }
  123.     /**
  124.      * 提供精确的乘法运算
  125.      *
  126.      * @param v1    被乘数
  127.      * @param v2    乘数
  128.      * @param scale 保留scale 位小数
  129.      * @return 两个参数的积
  130.      */
  131.     public static double mul(double v1, double v2, int scale) {
  132.         BigDecimal b1 = new BigDecimal(Double.toString(v1));
  133.         BigDecimal b2 = new BigDecimal(Double.toString(v2));
  134.         return round(b1.multiply(b2).doubleValue(), scale);
  135.     }
  137.     /**
  138.      * 提供精确的乘法运算
  139.      *
  140.      * @param v1    被乘数
  141.      * @param v2    乘数
  142.      * @param scale 保留scale 位小数
  143.      * @return 两个参数的积
  144.      */
  145.     public static String mul(String v1, String v2, int scale) {
  146.         if (scale < 0) {
  147.             throw new IllegalArgumentException(
  148.                     "The scale must be a positive integer or zero");
  149.         }
  150.         BigDecimal b1 = new BigDecimal(v1);
  151.         BigDecimal b2 = new BigDecimal(v2);
  152.         return b1.multiply(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
  153.     }
  155.     /**
  156.      * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到
  157.      * 小数点以后10位，以后的数字四舍五入
  158.      *
  159.      * @param v1 被除数
  160.      * @param v2 除数
  161.      * @return 两个参数的商
  162.      */
  164.     public static double div(double v1, double v2) {
  165.         return div(v1, v2, DEF_DIV_SCALE);
  166.     }
  168.     /**
  169.      * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
  170.      * 定精度，以后的数字四舍五入
  171.      *
  172.      * @param v1    被除数
  173.      * @param v2    除数
  174.      * @param scale 表示表示需要精确到小数点以后几位。
  175.      * @return 两个参数的商
  176.      */
  177.     public static double div(double v1, double v2, int scale) {
  178.         if (scale < 0) {
  179.             throw new IllegalArgumentException("The scale must be a positive integer or zero");
  180.         }
  181.         BigDecimal b1 = new BigDecimal(Double.toString(v1));
  182.         BigDecimal b2 = new BigDecimal(Double.toString(v2));
  183.         return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
  184.     }
  186.     /**
  187.      * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
  188.      * 定精度，以后的数字四舍五入
  189.      *
  190.      * @param v1    被除数
  191.      * @param v2    除数
  192.      * @param scale 表示需要精确到小数点以后几位
  193.      * @return 两个参数的商
  194.      */
  195.     public static String div(String v1, String v2, int scale) {
  196.         if (scale < 0) {
  197.             throw new IllegalArgumentException("The scale must be a positive integer or zero");
  198.         }
  199.         BigDecimal b1 = new BigDecimal(v1);
  200.         BigDecimal b2 = new BigDecimal(v1);
  201.         return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).toString();
  202.     }
  204.     /**
  205.      * 提供精确的小数位四舍五入处理
  206.      *
  207.      * @param v     需要四舍五入的数字
  208.      * @param scale 小数点后保留几位
  209.      * @return 四舍五入后的结果
  210.      */
  211.     public static double round(double v, int scale) {
  212.         if (scale < 0) {
  213.             throw new IllegalArgumentException("The scale must be a positive integer or zero");
  214.         }
  215.         BigDecimal b = new BigDecimal(Double.toString(v));
  216.         return b.setScale(scale, BigDecimal.ROUND_HALF_UP).doubleValue();
  217.     }
  219.     /**
  220.      * 提供精确的小数位四舍五入处理
  221.      *
  222.      * @param v     需要四舍五入的数字
  223.      * @param scale 小数点后保留几位
  224.      * @return 四舍五入后的结果
  225.      */
  226.     public static String round(String v, int scale) {
  227.         if (scale < 0) {
  228.             throw new IllegalArgumentException(
  229.                     "The scale must be a positive integer or zero");
  230.         }
  231.         BigDecimal b = new BigDecimal(v);
  232.         return b.setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
  233.     }
  235.     /**
  236.      * 取余数
  237.      *
  238.      * @param v1    被除数
  239.      * @param v2    除数
  240.      * @param scale 小数点后保留几位
  241.      * @return 余数
  242.      */
  243.     public static String remainder(String v1, String v2, int scale) {
  244.         if (scale < 0) {
  245.             throw new IllegalArgumentException(
  246.                     "The scale must be a positive integer or zero");
  247.         }
  248.         BigDecimal b1 = new BigDecimal(v1);
  249.         BigDecimal b2 = new BigDecimal(v2);
  250.         return b1.remainder(b2).setScale(scale, BigDecimal.ROUND_HALF_UP).toString();
  251.     }
  253.     /**
  254.      * 取余数  BigDecimal
  255.      *
  256.      * @param v1    被除数
  257.      * @param v2    除数
  258.      * @param scale 小数点后保留几位
  259.      * @return 余数
  260.      */
  261.     public static BigDecimal remainder(BigDecimal v1, BigDecimal v2, int scale) {
  262.         if (scale < 0) {
  263.             throw new IllegalArgumentException(
  264.                     "The scale must be a positive integer or zero");
  265.         }
  266.         return v1.remainder(v2).setScale(scale, BigDecimal.ROUND_HALF_UP);
  267.     }
  269.     /**
  270.      * 比较大小
  271.      * 阿里巴巴开发规范明确：比较BigDecimal的等值需要使用compareTo，不可用equals
  272.      * equals会比较值和精度，compareTo会忽略精度
  273.      * @param v1 被比较数
  274.      * @param v2 比较数
  275.      * @return 如果v1 大于v2 则 返回true 否则false
  276.      */
  277.     public static boolean compare(String v1, String v2) {
  278.         BigDecimal b1 = new BigDecimal(v1);
  279.         BigDecimal b2 = new BigDecimal(v2);
  280.         int bj = b1.compareTo(b2);
  281.         boolean res;
  282.         if (bj > 0)
  283.             res = true;
  284.         else
  285.             res = false;
  286.         return res;
  287.     }
  288. }

阿里巴巴Java开发手册关于BigDecimal的规定

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

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

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

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

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

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

参考阅读

  • LanceToBigData:Java之BigDecimal详解
  • 为什么阿里巴巴禁止使用BigDecimal的equals方法做等值比较？
  • java中double和float精度丢失问题
  • 深讨Java中double在计算时精度丢失的问题

发表评论

表情：
评论列表 （有 0 条评论，217人围观）

还没有评论，来说两句吧...

相关阅读

    相关 double精度丢失问题

    double精度丢失问题 从二进制角度考虑问题就会很简单了：把「0.1」转成二进制然后还原成十进制，就能看出问题。 这是二进制与十进制之间的碰撞 这是机器与

    叁歲伎倆叁歲伎倆/ 0 赞/ 702 阅读