Java数值计算精度、舍入和溢出问题

绝地灬酷狼 2022-11-14 10:12 206阅读 0赞

### 1. “危险”的 Double ###

先从简单的反直觉的四则运算看起。对几个简单的浮点数进行加减乘除运算

System.out.println(0.1+0.2);
    System.out.println(1.0-0.8);
    System.out.println(4.015*100);
    System.out.println(123.3/100);
    
    double amount1 = 2.15;
    double amount2 = 1.10;
    if (amount1 - amount2 == 1.05)
        System.out.println("OK");
    
    结果如下：
    
    0.30000000000000004
    0.19999999999999996
    401.49999999999994
    1.2329999999999999

可以看到，输出结果和我们预期的很不一样。比如，0.1+0.2 输出的不是 0.3 而是 0.30000000000000004。出现这种问题的主要原因是，计算机是以二进制存储数值的，浮点数也不例外。Java 采用了IEEE 754 标准实现浮点数的表达和运算，你可以通过这里查看数值转化为二进制的结果。比如，0.1 的二进制表示为 0.0 0011 0011 … （0011 无限循环)，再转换为十进制就是0.1000000000000000055511151231257827021181583404541015625。对于计算机而言，0.1 无法精确表达，这是浮点数计算造成精度损失的根源。

优化方案：

BigDecimal 类型，浮点数精确表达和运算的场景，一定要使用这个类型。不过，在使用 BigDecimal 时有几个坑需要避开。我们用 BigDecimal 把之前的四则运算改一下：

System.out.println(new BigDecimal(0.1).add(new BigDecimal(0.2)));
    System.out.println(new BigDecimal(1.0).subtract(new BigDecimal(0.8)));
    System.out.println(new BigDecimal(4.015).multiply(new BigDecimal(100)));
    System.out.println(new BigDecimal(123.3).divide(new BigDecimal(100)));
    
    结果如下：
    
    0.3000000000000000166533453693773481063544750213623046875
    0.1999999999999999555910790149937383830547332763671875
    401.49999999999996802557689079549163579940795898437500
    1.232999999999999971578290569595992565155029296875

可以看到，运算结果还是不精确，只不过是精度高了而已。浮点数运算避坑第一原则：使用 BigDecimal 表示和计算浮点数，且务必使用字符串的构造方法来初始化 BigDecimal

System.out.println(new BigDecimal("0.1").add(new BigDecimal("0.2")));
    System.out.println(new BigDecimal("1.0").subtract(new BigDecimal("0.8")));
    System.out.println(new BigDecimal("4.015").multiply(new BigDecimal("100")));
    System.out.println(new BigDecimal("123.3").divide(new BigDecimal("100")));
    
    结果如下：
    
    0.3
    0.2
    401.500
    1.233

### 2.用 equals 做判等，就一定是对的吗？ ###

现在我们知道了，应该使用 BigDecimal 来进行浮点数的表示、计算。并且包装类的比较要通过 equals 进行，而不能使用 ==。那么，使用 equals 方法对两个 BigDecimal 判等，一定能得到我们想要的结果吗？

boolean  res  = new BigDecimal("1.0").equals(new BigDecimal("1"));
    System.out.println(res);
    
    结果如下：
    false

BigDecimal 的 equals 方法的注释中说明了原因，equals 比较的是 BigDecimal 的 value 和 scale，1.0 的 scale 是 1，1 的 scale 是 0，所以结果一定是 false。源码如下：

/**
     * Compares this {@code BigDecimal} with the specified
     * {@code Object} for equality.  Unlike {@link
     * #compareTo(BigDecimal) compareTo}, this method considers two
     * {@code BigDecimal} objects equal only if they are equal in
     * value and scale (thus 2.0 is not equal to 2.00 when compared by
     * this method).
     *
     * @param  x {@code Object} to which this {@code BigDecimal} is
     *         to be compared.
     * @return {@code true} if and only if the specified {@code Object} is a
     *         {@code BigDecimal} whose value and scale are equal to this
     *         {@code BigDecimal}'s.
     * @see    #compareTo(java.math.BigDecimal)
     * @see    #hashCode
     */
    @Override
    public boolean equals(Object x)

优化方案：

如果我们希望只比较 BigDecimal 的 value，可以使用 compareTo 方法。

boolean  res  = new BigDecimal("1.0").compareTo(new BigDecimal("1")) == 0;
     System.out.println(res);

### 3. 小心数值溢出问题 ###

数值计算还有一个要小心的点是溢出，不管是 int 还是 long，所有的基本数值类型都有超出表达范围的可能性。比如，对 Long 的最大值进行 +1 操作，显然这是发生了溢出，而且是默默地溢出，并没有任何异常。

long l = Long.MAX_VALUE;
    System.out.println(l + 1);
    System.out.println(l + 1 == Long.MIN_VALUE);
    
    结果如下：
    
    -9223372036854775808
    true

优化方案：

方案一：使用 Math 类的 addExact、subtractExact 等 xxExact 方法进行数值运算，这些方法可以在数值溢出时主动抛出异常。

try {
        long l = Long.MAX_VALUE;
        System.out.println(Math.addExact(l, 1));
    } catch (Exception ex) {
        ex.printStackTrace();
    }
    
    运行结果：
    
    java.lang.ArithmeticException: long overflow
      at java.lang.Math.addExact(Math.java:809)
      at org.geekbang.time.commonmistakes.numeralcalculations.demo3.CommonMistakesApplication.right2(CommonMistakesApplication.java:25)
      at org.geekbang.time.commonmistakes.numeralcalculations.demo3.CommonMistakesApplication.main(CommonMistakesApplication.java:13)

方案二：使用大数类 BigInteger。BigDecimal 是处理浮点数的专家，而 BigInteger 则是对大数进行科学计算的专家。

BigInteger i = new BigInteger(String.valueOf(Long.MAX_VALUE));
    System.out.println(i.add(BigInteger.ONE).toString());
    
    
    运行结果
    
    9223372036854775808

### 重点回顾 ###

今天，我与你分享了浮点数的表示、计算、舍入和格式化、溢出等涉及的一些坑。

第一，切记，要精确表示浮点数应该使用 BigDecimal。并且，使用 BigDecimal 的 Double 入参的构造方法同样存在精度丢失问题，应该使用 String 入参的构造方法或者 BigDecimal.valueOf 方法来初始化。

第二，对浮点数做精确计算，参与计算的各种数值应该始终使用 BigDecimal，所有的计算都要通过 BigDecimal 的方法进行，切勿只是让 BigDecimal 来走过场。任何一个环节出现精度损失，最后的计算结果可能都会出现误差。

第三，对于浮点数的格式化，如果使用 String.format 的话，需要认识到它使用的是四舍五入，可以考虑使用 DecimalFormat 来明确指定舍入方式。但考虑到精度问题，我更建议使用 BigDecimal 来表示浮点数，并使用其 setScale 方法指定舍入的位数和方式。

第四，进行数值运算时要小心溢出问题，虽然溢出后不会出现异常，但得到的计算结果是完全错误的。我们考虑使用 Math.xxxExact 方法来进行运算，在溢出时能抛出异常，更建议对于可能会出现溢出的大数运算使用 BigInteger 类。

总之，对于金融、科学计算等场景，请尽可能使用 BigDecimal 和 BigInteger，避免由精度和溢出问题引发难以发现，但影响重大的 Bug。

### 思考与讨论 ###

1.BigDecimal提供了 8 种舍入模式，你能通过一些例子说说它们的区别吗？

2.数据库（比如 MySQL）中的浮点数和整型数字，你知道应该怎样定义吗？又如何实现浮点数的准确计算呢？