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

开篇，国际惯例模式 “先吹牛”，先给小白科普一下 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）

最后

以上就是呆萌黑米为你收集整理的Java BigDecimal 精度计算 “舍入” 你用对了吗？的全部内容，希望文章能够帮你解决Java BigDecimal 精度计算 “舍入” 你用对了吗？所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。