Java随笔:0.1 + 0.2 != 0.3 ?

Ginkgo True love prevails.

“For you, a thousand times over.”


问题引入

今天学习 Java 时,老师突然提了一个问题:

1
System.out.println(0.1 + 0.2);

在 Java 中,上述表达式输出的值应该是多少?

这事出反常必有妖,要是问题这么简单又怎么会专门提出来呢?我立马掏出 VSCode,用最快的速度码好了如下代码:

1
2
3
4
5
public class Test {
public static void main(String[] args) {
System.out.println(0.1 + 0.2);
}
}

编译器给出的结论:0.30000000000000004

我一数,好家伙,小数点后竟足足有 17 位!这个答案虽然有点意外,但似乎也在意料之中。

那,到底是什么原因导致了这种情况呢?

在 Google 一番并研究了好一阵子后,大概明白了一些。而且,似乎很多前辈们都曾在面试的时候折戟于这道看上去很 “简单” 的题目……


原理解释

首先,我们都知道,计算机是以二进制的形式进行存储的,数值也不例外。

Java 采用 IEEE 754 标准 来实现浮点数的表达、运算和存储。

以 0.1 而言,它的本质是 1/10,用二进制表示的话,就是 1/1010。然而问题就出现了——你会惊奇地发现,在二进制下,这个数是除不尽的,是一个无穷循环小数!

计算结果为:0.0001100110011001100110011…(0011 无限循环)

采用二进制下的科学计数法表示,则为:

下面是 IEEE 754 标准 double 类型的计算公式:

其中:

  • :符号位(sign)
  • :指数位(exponent),11 位
  • :尾数位(fraction),52 位

由上述科学计数法我们可以得到 exponent 的值为 -4,所以 的取值为 1019(1019 - 1023 = -4)。

1019 用 11 位二进制表示为:011 1111 1011

尾数部分为 1.1001100110011…,隐藏 1 后存储 fraction 部分。

因为 0.1 为正数,所以符号位 sign 取值为 0。

0.1 在 IEEE 754 双精度标准下的二进制存储格式如下:

1
0 01111111011 100110011001...(52 位 1001 循环)

用该二进制形式逆推回十进制,首先计算 fraction 部分,观察规律不难发现:

最后计算出的值约为 0.6,再加上前面所隐藏的 1,可以得出 约为 1.6,再乘以 ,得出结果大约为 0.1。

但 毕竟是约值,由于尾数位数有限,真实值可求:

简单总结

1/10 无法用有限位数的二进制数进行表示,导致在 IEEE 754 标准下存储时存在数据截断问题,最终造成精度损失。


解决方法

同学们可能很疑惑:0.1 的精度损失也太小了吧,而且不会对计算产生很大影响。大不了下次比较的时候限制一下位数,四舍五入舍弃掉后面的误差值不就好了?

在我们平日简单的计算过程中,确实不必处心积虑地考虑这精度问题。但对于某些特别的场景,这种精度问题就必须要考虑了。

举个例子:如果我们大量使用 double 来进行金钱计算,只要数额够大,那 double 所损失的精度最终就会转换为白花花的 Money 💰

那么,我们该如何解决这个问题呢?

BigDecimal 登场

BigDecimal 类型可以准确地表达和运算高精度的浮点数,但在使用前,有几个坑需要我们避开。

首先,使用前需导入:

1
import java.math.BigDecimal;

在使用时,如果不想用变量存储,在表达式中一定要 创建并初始化 数据:

1
2
3
4
5
6
// 变量形式
BigDecimal tmp = new BigDecimal(1.0);
System.out.println(tmp);

// 临时变量形式
System.out.println(new BigDecimal(1.0));

四则运算需要使用点运算符调用:

1
2
3
4
5
6
7
8
BigDecimal u = new BigDecimal(1.0);
BigDecimal v = new BigDecimal(1.0);

u.add(v); // 加法
u.subtract(v); // 减法
u.multiply(v); // 乘法
u.divide(v); // 除法
u.abs(); // 绝对值

然后,我们就可以使用以下语句来输出 0.1 + 0.2 的值了:

1
System.out.println(new BigDecimal(0.1).add(new BigDecimal(0.2)));

输出如下:

1
0.3000000000000000166533453693773481063544750213623046875

可以看到,虽然精度略有提高,但运算结果还不是完全精确。难道 BigDecimal 也不能完全精确吗?

非也,非也! 这里就是要强调的一个大坑了 ⚠️

在进行浮点数运算时,使用 BigDecimal 表示和计算浮点数,务必使用字符串的构造方法来初始化!

所以正确的表达式应该如下:

1
System.out.println(new BigDecimal("0.1").add(new BigDecimal("0.2")));

修正过后,我们终于可以达成 0.1 + 0.2 == 0.3 了 ✅


参考资料

  • Title: Java随笔:0.1 + 0.2 != 0.3 ?
  • Author: Ginkgo
  • Created at : 2022-09-19 19:00:00
  • Updated at : 2026-04-26 21:32:57
  • Link: https://g1nkgo7.github.io/2022/09/19/Java随笔-浮点数精度/
  • License: This work is licensed under CC BY-NC-SA 4.0.
Comments
On this page
Java随笔:0.1 + 0.2 != 0.3 ?