写点什么

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

发布于: 2020 年 12 月 29 日
Java:利用BigDecimal类巧妙处理Double类型精度丢失

本篇要点

  • 简单描述浮点数十进制转二进制精度丢失的原因。

  • 介绍几种创建 BigDecimal 方式的区别。

  • 整理了高精度计算的工具类。

  • 学习了阿里巴巴 Java 开发手册关于 BigDecimal 比较相等的规定。

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

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

关于浮点数存储精度丢失的问题,话题过于庞大,感兴趣的同学可以自行搜索一下

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

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

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

5 / 2 = 2 余 12 / 2 = 1 余 01 / 2 = 0 余 1     // 结果为 101
复制代码

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

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

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

0.1 * 2 = 0.2 取整数部分00.2 * 2 = 0.4 取整数部分00.4 * 2 = 0.8 取整数部分00.8 * 2 = 1.6 取整数部分10.6 * 2 = 1.2 取整数部分10.2 * 2 = 0.4 取整数部分0 
//... 我想写到这就不必再写了,你应该也已经发现,上面的过程已经开始循环,小数部分永远不能为0
复制代码

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

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

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

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

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

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.1000000000000000055511151231257827021181583404541015625b --> 0.1c --> 0.1
复制代码

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

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

// 传入double	public BigDecimal(double val) {        this(val,MathContext.UNLIMITED);    }	// 传入string    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 标注:

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

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 的对象。网上有很多这样的工具类,这边直接贴一下,逻辑不难,主要为了简化项目中频繁互相转化的问题。

/** * 用于高精确处理常用的数学运算 */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); }
/** * 比较大小 * 阿里巴巴开发规范明确:比较BigDecimal的等值需要使用compareTo,不可用equals * 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) <op> 0 来表示(<, == , > , >= , != , <=)中的其中一个关系,就表示运算符。

  • equals 方法与 compareTo 方法不同,此方法仅在两个 BigDecimal 对象的值和精度都相等时才被认为是相等的,如 2.0 和 2.00 就是不相等的。

原文链接:https://www.cnblogs.com/summerday152/p/14202267.html

如果觉得本文对你有帮助,可以关注一下我公众号,回复关键字【面试】即可得到一份 Java 核心知识点整理与一份面试大礼包!另有更多技术干货文章以及相关资料共享,大家一起学习进步!


发布于: 2020 年 12 月 29 日阅读数: 28
用户头像

领取资料添加小助理vx:bjmsb2020 2020.12.19 加入

Java领域;架构知识;面试心得;互联网行业最新资讯

评论

发布
暂无评论
Java:利用BigDecimal类巧妙处理Double类型精度丢失