Java BigDecimal 精度计算 “舍入” 你用对了吗？

一时失言乱红尘 2022-12-09 15:59 199阅读 0赞

开篇，国际惯例模式 “先吹牛”，先给小白科普一下 `BigDecimal`。

Java在java.math包中提供的API类BigDecimal，用来对超过16位有效位的数进行精确的运算。双精度浮点型变量double可以处理16位有效数，但在实际应用中，可能需要对更大或者更小的数进行运算和处理。一般情况下，对于那些不需要准确计算精度的数字，我们可以直接使用Float和Double处理，但是Double.valueOf(String) 和Float.valueOf(String)会丢失精度。所以开发中，如果我们需要精确计算的结果，则必须使用BigDecimal类来操作。

BigDecimal所创建的是对象，故我们不能使用传统的+、-、\*、/等算术运算符直接对其对象进行数学运算，而必须调用其相对应的方法。方法中的参数也必须是BigDecimal的对象。构造器是类的特殊方法，专门用来创建对象，特别是带有参数的对象。

**常用构造函数**

*  BigDecimal(int)  
    创建一个具有参数所指定整数值的对象
 *  BigDecimal(double)  
    创建一个具有参数所指定双精度值的对象
 *  BigDecimal(long)  
    创建一个具有参数所指定长整数值的对象
 *  BigDecimal(String)  
    创建一个具有参数所指定以字符串表示的数值的对象

**常用方法**

*  `add(BigDecimal)`  
    BigDecimal对象中的值相加，返回BigDecimal对象
 *  `subtract(BigDecimal)`  
    BigDecimal对象中的值相减，返回BigDecimal对象
 *  `multiply(BigDecimal)`  
    BigDecimal对象中的值相乘，返回BigDecimal对象
 *  `divide(BigDecimal)`  
    BigDecimal对象中的值相除，返回BigDecimal对象
 *  toString()  
    将BigDecimal对象中的值转换成字符串
 *  doubleValue()  
    将BigDecimal对象中的值转换成双精度数
 *  floatValue()  
    将BigDecimal对象中的值转换成单精度数
 *  longValue()  
    将BigDecimal对象中的值转换成长整数
 *  intValue()  
    将BigDecimal对象中的值转换成整数
 *  compareTo()  
    两个 BigDecimal 的大小比较

**格式化**

搭配 `NumberFormat` 类的 `format()` 方法可以直接将 `BigDecimal` 对象作为参数进行格式化处理，可以对超出16位有效数字的货币值、百分值、以及一般数值进行格式化控制。

**精度处理**

这里是本文重点要科普的点，虽然内容不多，但是较为重要！如果你做银行、金融相关领域，则更应该掌握。

打开 BigDecimal 类，可以看到如下几个常量，下文已经给出中文解释：

/**
         * Rounding mode to round away from zero.  Always increments the
         * digit prior to a nonzero discarded fraction.  Note that this rounding
         * mode never decreases the magnitude of the calculated value.
         */
         // 舍入远离零的舍入模式。
         // 在丢弃非零部分之前始终增加数字（始终对非零舍弃部分前面的数字加1）。
         // 注意，此舍入模式始终不会减少计算值的大小。
        public final static int ROUND_UP =           0;
    
        /**
         * Rounding mode to round towards zero.  Never increments the digit
         * prior to a discarded fraction (i.e., truncates).  Note that this
         * rounding mode never increases the magnitude of the calculated value.
         */
         // 接近零的舍入模式。
         // 在丢弃某部分之前始终不增加数字（从不对舍弃部分前面的数字加1，即截短）。
         // 注意，此舍入模式始终不会增加计算值的大小。
        public final static int ROUND_DOWN =         1;
    
        /**
         * Rounding mode to round towards positive infinity.  If the
         * {@code BigDecimal} is positive, behaves as for
         * {@code ROUND_UP}; if negative, behaves as for
         * {@code ROUND_DOWN}.  Note that this rounding mode never
         * decreases the calculated value.
         */
         // 接近正无穷大的舍入模式。
         // 如果 BigDecimal 为正，则舍入行为与 ROUND_UP 相同，如果为负，则舍入行为与 ROUND_DOWN 相同。
         // 注意，此舍入模式始终不会减少计算值。
        public final static int ROUND_CEILING =      2;
    
        /**
         * Rounding mode to round towards negative infinity.  If the
         * {@code BigDecimal} is positive, behave as for
         * {@code ROUND_DOWN}; if negative, behave as for
         * {@code ROUND_UP}.  Note that this rounding mode never
         * increases the calculated value.
         */
         // 接近负无穷大的舍入模式。
         // 如果 BigDecimal 为正，则舍入行为与 ROUND_DOWN 相同，如果为负，则舍入行为与 ROUND_UP 相同。
         // 注意，此舍入模式始终不会增加计算值。
        public final static int ROUND_FLOOR =        3;
    
        /**
         * Rounding mode to round towards {@literal "nearest neighbor"}
         * unless both neighbors are equidistant, in which case round up.
         * Behaves as for {@code ROUND_UP} if the discarded fraction is
         * ≥ 0.5; otherwise, behaves as for {@code ROUND_DOWN}.  Note
         * that this is the rounding mode that most of us were taught in
         * grade school.
         */
         // 向“最接近的”数字舍入，如果与两个相邻数字的距离相等，则为向上舍入的舍入模式。
         // 如果舍弃部分 >= 0.5，则舍入行为与 ROUND_UP 相同;否则舍入行为与 ROUND_DOWN 相同。
         // 注意，这是我们大多数人在小学时就学过的舍入模式（四舍五入）。
        public final static int ROUND_HALF_UP =      4;
    
        /**
         * Rounding mode to round towards {@literal "nearest neighbor"}
         * unless both neighbors are equidistant, in which case round
         * down.  Behaves as for {@code ROUND_UP} if the discarded
         * fraction is {@literal >} 0.5; otherwise, behaves as for
         * {@code ROUND_DOWN}.
         */
         // 向“最接近的”数字舍入，如果与两个相邻数字的距离相等，则为上舍入的舍入模式。
         // 如果舍弃部分 > 0.5，则舍入行为与 ROUND_UP 相同，否则舍入行为与 ROUND_DOWN 相同（五舍六入）。
        public final static int ROUND_HALF_DOWN =    5;
    
        /**
         * Rounding mode to round towards the {@literal "nearest neighbor"}
         * unless both neighbors are equidistant, in which case, round
         * towards the even neighbor.  Behaves as for
         * {@code ROUND_HALF_UP} if the digit to the left of the
         * discarded fraction is odd; behaves as for
         * {@code ROUND_HALF_DOWN} if it's even.  Note that this is the
         * rounding mode that minimizes cumulative error when applied
         * repeatedly over a sequence of calculations.
         */
         // 向“最接近的”数字舍入，如果与两个相邻数字的距离相等，则向相邻的偶数舍入。
         // 如果舍弃部分左边的数字为奇数，则舍入行为与 ROUND_HALF_UP 相同，如果为偶数，则舍入行为与 ROUND_HALF_DOWN 相同。
         // 注意，在重复进行一系列计算时，此舍入模式可以将累加错误减到最小。
         // 此舍入模式也称为“银行家舍入法”，它主要是针对5的去留做的设计。
         // 你只需要记住一点：当5的前面是偶数，并且5的后面一位不是0的情况下，这个5才会直接舍去，否则都是进。
         // 以下例子为保留小数点1位，那么这种舍入方式后的结果为：1.15=1.2、1.25=1.2、1.151=1.2、1.251=1.3
        public final static int ROUND_HALF_EVEN =    6;
    
        /**
         * Rounding mode to assert that the requested operation has an exact
         * result, hence no rounding is necessary.  If this rounding mode is
         * specified on an operation that yields an inexact result, an
         * {@code ArithmeticException} is thrown.
         */
         // 断言请求的操作具有精确的结果，因此不需要舍入。
         // 如果对获得精确结果的操作指定此舍入模式，则抛出ArithmeticException。
        public final static int ROUND_UNNECESSARY =  7;

> 所谓银行家舍入法，其实质是一种四舍六入五取偶（又称四舍六入五留双）法。

紧接着我来考你一下，下面的代码输出结果是什么？

System.out.println(new BigDecimal(1.15).setScale(1,BigDecimal.ROUND_HALF_EVEN).toString());

如果你告诉我输出的是 1.2，那你就又错了，它输出的结果是 1.1。  
哈哈哈……

我来告诉你为什么，代码中 `new BigDecimal(1.15)` 会丢失精度，请使用 `new BigDecimal("1.15")` 这样的写法！

--------------------

所以，**银行家舍入法** `BigDecimal.ROUND_HALF_EVEN` 应当选本文的主角，请记住它。

最后，为什么银行家舍入是相对很合理的呢？这个问题留给你，数据模型会告诉你答案 —— 它确实相对很合理。

--------------------

（END）