模块 java.base
包 java.math

类 BigDecimal

java.lang.Object
java.lang.Number
java.math.BigDecimal
所有已实现的接口：
Serializable , Comparable<BigDecimal>
public class BigDecimal extends Number implements Comparable <BigDecimal >
不可变的、任意精度的带符号十进制数。 BigDecimal 由任意精度整数组成未缩放的值 和一个 32 位整数scale .如果小数位数为零或正数，则小数位数为小数点右侧的位数。如果标度为负，则数字的未标度值乘以 10 的标度的负数次方。 BigDecimal 代表的数字的值因此是 (unscaledValue × 10-scale) 。

BigDecimal 类提供算术、比例操作、舍入、比较、散列和格式转换的操作。 toString() 方法提供了 BigDecimal 的规范表示。

BigDecimal 类为其用户提供了对舍入行为的完全控制。如果没有指定舍入模式并且无法表示准确的结果，则抛出一个ArithmeticException；否则，可以通过向操作提供适当的 MathContext 对象来执行选定精度和舍入模式的计算。无论哪种情况，都提供了八个rounding modes来控制舍入。使用此类中的整数字段（例如 ROUND_HALF_UP ）来表示舍入模式已被弃用；应该使用 RoundingMode enum 的枚举值（例如 RoundingMode.HALF_UP ）。

当 MathContext 对象的精度设置为 0（例如 MathContext.UNLIMITED ）时，算术运算是精确的，不采用 MathContext 对象的算术方法也是如此。作为计算精确结果的必然结果，不使用精度设置为 0 的 MathContext 对象的舍入模式设置，因此不相关。在除法的情况下，确切的商可以有一个无限长的小数展开；例如，1 除以 3。如果商具有非终止小数扩展并且指定操作返回精确结果，则抛出 ArithmeticException。否则，与其他操作一样，返回除法的确切结果。

当精度设置不为 0 时， BigDecimal 算术规则与 ANSI X3.274-1996 和 ANSI X3.274-1996/AM 1-2000（第 7.4 节）中定义的算术运算的选定模式广泛兼容。与那些标准不同，BigDecimal 包括许多舍入模式。这些 ANSI 标准与 BigDecimal 规范之间的任何冲突均以 BigDecimal 为准解决。

由于相同的数值可以有不同的表示（具有不同的标度），算术和舍入规则必须指定数值结果和结果表示中使用的标度。同一个数值的不同表示称为同一个成员队列BigDecimal 的 自然秩序 认为同一队列的成员彼此平等。相反，equals 方法要求数值和表示都相同才能保持相等。 scale 和 unscaledValue() 等方法的结果对于具有不同表示的数值相等值会有所不同。

通常，舍入模式和精度设置决定了当精确结果的位数多于返回的位数时（在除法和平方根的情况下可能无限多），操作如何返回位数有限的结果。首先，要返回的总位数由 MathContext 的 precision 设置指定；这决定了结果的精确.数字计数从确切结果的最左边的非零数字开始。舍入模式决定了任何丢弃的尾随数字如何影响返回的结果。

对于所有算术运算符，运算的执行就好像首先计算出精确的中间结果，然后使用所选的舍入模式舍入到精度设置指定的位数（如有必要）。如果没有返回准确结果，则丢弃准确结果的部分位。当舍入增加返回结果的大小时，可能会通过进位传播到前导“9”数字来创建新的数字位置。例如，将值 999.9 四舍五入到三位四舍五入在数值上等于一千，表示为 100×101.在这种情况下，新的“1”是返回结果的前导数字位置。

对于带有 MathContext 参数的方法和构造函数，如果结果不准确但舍入模式为 UNNECESSARY ，将抛出 ArithmeticException。

除了逻辑上的精确结果外，每个算术运算都有一个首选的标度来表示结果。下表列出了每个操作的首选比例。

算术运算结果的首选尺度
Operation 结果的首选规模
添加 最大值（加数.scale(), augend.scale())
减去 最大（minuend.scale（），减数。scale（））
Multiply 乘数.scale() + 被乘数.scale()
划分 dividend.scale() - 除数.scale()
平方根 radicand.scale()/2
这些尺度是返回精确算术结果的方法所使用的尺度；除了精确的除法可能必须使用更大的比例，因为精确的结果可能有更多的数字。例如，1/32 是 0.03125。

在舍入之前，逻辑精确中间结果的小数位数是该操作的首选小数位数。如果准确的数值结果不能用precision位表示，则舍入选择要返回的位数集合，结果的小数位从中间结果的小数位缩减到能代表实际返回的precision位的最小小数位。如果精确结果最多可以用 precision 位数字表示，则返回具有最接近首选比例的比例的结果表示。特别是，通过删除尾随零和减小比例，可以用少于 precision 位的数字来表示可精确表示的商。例如，使用floor舍入模式舍入到三位数，
19/100 = 0.19 // integer=19, scale=2
但
21/110 = 0.190 // integer=190, scale=3

请注意，对于加法、减法和乘法，小数位数的减少将等于精确结果中被丢弃的位数。如果舍入导致进位传播创建新的高位数字位置，则与未创建新数字位置时相比，结果的额外数字将被丢弃。

其他方法可能具有略微不同的舍入语义。例如，使用 指定算法 的 pow 方法的结果偶尔会与四舍五入的数学结果相差不止一个单位在最后一位，一个ulp .

提供了两种类型的操作来操纵 BigDecimal 的比例：缩放/舍入操作和小数点运动操作。缩放/舍入操作（setScale 和 round ）返回一个 BigDecimal ，其值大约（或恰好）等于操作数的值，但其小数位数或精度为指定值；也就是说，它们增加或减少存储数字的精度，而对其值的影响最小。小数点运动操作（movePointLeft 和 movePointRight ）返回一个 BigDecimal 通过在指定方向上将小数点移动指定距离从操作数创建。

作为一个 32 位整数，比例的值集很大，但有界。如果结果的小数位数超过 32 位整数的范围，无论是溢出还是下溢，操作可能会抛出 ArithmeticException 。

为了简洁明了，在整个BigDecimal方法的描述中都使用了伪代码。伪代码表达式 (i + j) 是“一个 BigDecimal 的简写，其值是 BigDecimal i 的值加上 BigDecimal j 的值。”伪代码表达式 (i == j) 是“true 当且仅当 BigDecimal i 表示与 BigDecimal j 相同的值时的简写。”其他伪代码表达式的解释类似。方括号用于表示定义 BigDecimal 值的特定 BigInteger 和比例对；例如 [19, 2] 是 BigDecimal 在数值上等于 0.19，比例为 2。

当为任何输入参数传递 null 对象引用时，此类的所有方法和构造函数都会抛出 NullPointerException。

API 注意：
如果 BigDecimal 对象被用作 SortedMap 中的键或 SortedSet 中的元素，因为 BigDecimal 的自然排序 是inconsistent with equals。有关详细信息，请参阅 Comparable 、SortedMap 或 SortedSet 。

与 IEEE 754 十进制算法的关系

从 2008 年修订版开始，IEEE 754 浮点运算标准涵盖了十进制格式和操作。虽然 IEEE 754 和此类定义的十进制算术有广泛的相似之处，但也存在显着差异。 BigDecimal 和 IEEE 754 十进制算术共享的基本相似性是计算运算的数学无限精确实数值然后将该实数映射到 rounding policy 下的可表示十进制浮点值的概念运算。舍入策略称为 BigDecimal 的 舍入模式，在 IEEE 754-2019 中称为舍入方向属性。当精确值不可表示时，舍入策略决定选择包含精确值的两个可表示小数值中的哪一个作为计算结果。 preferred scale/preferred exponent 的概念也被两个系统共享。

对于差异，IEEE 754 包括几种未由 BigDecimal 建模的值，包括负零、有符号无穷大和 NaN（非数字）。 IEEE 754 定义了格式，这些格式由基数（二进制或十进制）、精度位数和指数范围参数化。格式决定了可表示值的集合。大多数操作接受给定格式的一个或多个值作为输入，并产生相同格式的结果。 BigDecimal 的 scale 相当于取反 IEEE 754 值的指数。 BigDecimal 值没有相同意义的格式；所有值都具有相同的可能范围/指数，并且 未缩放的值 具有任意精度。相反，对于采用 MathContext 参数的 BigDecimal 操作，如果 MathContext 具有非零精度，则结果的可能表示值集由 MathContext 参数的精度确定。例如在 BigDecimal 中，如果在精度为三的 MathContext 对象的上下文中将一个非零三位数和一个非零四位数相乘，则结果将具有三位数（假设没有溢出或下溢等）。 ).

由 舍入模式 指示的 BigDecimal 操作实现的舍入策略是 IEEE 754 舍入方向属性的适当超集。

如果对应于 IEEE 754 十进制格式（例如 十进制64位 或 十进制128）的 MathContext 用于舍入所有起始值和中间操作，则 BigDecimal 算术将最类似于 IEEE 754 十进制算术。如果超过 IEEE 754 格式的近似指数范围，则计算出的数值可能会有所不同，因为 MathContext 不限制 BigDecimal 结果的比例。将生成 NaN 或精确无穷大的操作（例如除以零）会在 BigDecimal 算术中抛出 ArithmeticException。

自从：
1.1
参见：

  • 字段详细信息

    • ZERO

      public static final BigDecimal  ZERO
      值为 0，比例为 0。
      自从：
      1.5

    • ONE

      public static final BigDecimal  ONE
      值为 1，比例为 0。
      自从：
      1.5

    • TWO

      public static final BigDecimal  TWO
      值为 2，比例为 0。
      自从：
      19

    • TEN

      public static final BigDecimal  TEN
      值为 10，比例为 0。
      自从：
      1.5

    • ROUND_UP

      @Deprecated (since ="9") public static final int ROUND_UP
      已弃用。
      请改用 RoundingMode.UP 。
      从零舍入的舍入模式。始终递增非零丢弃分数之前的数字。请注意，这种舍入模式永远不会减小计算值的大小。
      参见：

    • ROUND_DOWN

      @Deprecated (since ="9") public static final int ROUND_DOWN
      已弃用。
      请改用 RoundingMode.DOWN 。
      向零舍入的舍入模式。永远不要在丢弃的分数之前增加数字（即截断）。请注意，这种舍入模式永远不会增加计算值的大小。
      参见：

    • ROUND_CEILING

      @Deprecated (since ="9") public static final int ROUND_CEILING
      已弃用。
      请改用 RoundingMode.CEILING 。
      向正无穷大舍入的舍入模式。如果 BigDecimal 为正，则表现与 ROUND_UP 相同；如果为负，则行为与 ROUND_DOWN 相同。请注意，这种舍入模式永远不会减少计算值。
      参见：

    • ROUND_FLOOR

      @Deprecated (since ="9") public static final int ROUND_FLOOR
      已弃用。
      请改用 RoundingMode.FLOOR 。
      向负无穷大舍入的舍入模式。如果 BigDecimal 为正，则表现与 ROUND_DOWN 相同；如果为负，则与 ROUND_UP 一样。请注意，这种舍入模式永远不会增加计算值。
      参见：

    • ROUND_HALF_UP

      @Deprecated (since ="9") public static final int ROUND_HALF_UP
      已弃用。
      请改用 RoundingMode.HALF_UP 。
      舍入模式向“最近的邻居”舍入，除非两个邻居是等距的，在这种情况下舍入。如果丢弃的分数 ≥ 0.5，则与 ROUND_UP 一样；否则，行为与 ROUND_DOWN 相同。请注意，这是我们大多数人在小学时教授的舍入模式。
      参见：

    • ROUND_HALF_DOWN

      @Deprecated (since ="9") public static final int ROUND_HALF_DOWN
      已弃用。
      请改用 RoundingMode.HALF_DOWN 。
      舍入模式向“最近的邻居”舍入，除非两个邻居是等距的，在这种情况下向下舍入。如果丢弃的分数 > 0.5，则与 ROUND_UP 一样；否则，行为与 ROUND_DOWN 相同。
      参见：

    • ROUND_HALF_EVEN

      @Deprecated (since ="9") public static final int ROUND_HALF_EVEN
      已弃用。
      请改用 RoundingMode.HALF_EVEN 。
      舍入模式向“最近的邻居”舍入，除非两个邻居都是等距的，在这种情况下，向偶数邻居舍入。如果丢弃分数左侧的数字是奇数，则与 ROUND_HALF_UP 一样；如果它是偶数，其行为与 ROUND_HALF_DOWN 相同。请注意，这是一种舍入模式，可在重复应用于一系列计算时最大限度地减少累积误差。
      参见：

    • ROUND_UNNECESSARY

      @Deprecated (since ="9") public static final int ROUND_UNNECESSARY
      已弃用。
      请改用 RoundingMode.UNNECESSARY 。
      舍入模式断言所请求的操作具有准确的结果，因此不需要舍入。如果在产生不精确结果的操作上指定了此舍入模式，则会抛出 ArithmeticException。
      参见：

  • 构造方法详细信息

    • BigDecimal

      public BigDecimal(char[] in, int offset, int len)
      将 BigDecimal 的字符数组表示形式转换为 BigDecimal ，接受与 BigDecimal(String) 构造函数相同的字符序列，同时允许指定子数组。
      实现注意事项：
      如果字符序列在字符数组中已经可用，则使用此构造函数比将 char 数组转换为字符串并使用 BigDecimal(String) 构造函数更快。
      参数：
      in - char 数组即字符来源。
      offset - 数组中要检查的第一个字符。
      len - 要考虑的字符数。
      抛出：
      NumberFormatException - 如果 in 不是 BigDecimal 的有效表示，或者定义的子数组不完全在 in 内。
      自从：
      1.5

    • BigDecimal

      public BigDecimal(char[] in, int offset, int len, MathContext  mc)
      将 BigDecimal 的字符数组表示形式转换为 BigDecimal ，接受与 BigDecimal(String) 构造函数相同的字符序列，同时允许指定子数组并根据上下文设置进行舍入。
      实现注意事项：
      如果字符序列在字符数组中已经可用，则使用此构造函数比将 char 数组转换为字符串并使用 BigDecimal(String) 构造函数更快。
      参数：
      in - char 数组即字符来源。
      offset - 数组中要检查的第一个字符。
      len - 要考虑的字符数。
      mc - 要使用的上下文。
      抛出：
      NumberFormatException - 如果 in 不是 BigDecimal 的有效表示，或者定义的子数组不完全在 in 内。
      自从：
      1.5

    • BigDecimal

      public BigDecimal(char[] in)
      将 BigDecimal 的字符数组表示形式转换为 BigDecimal ，接受与 BigDecimal(String) 构造函数相同的字符序列。
      实现注意事项：
      如果字符序列已作为字符数组可用，则使用此构造函数比将 char 数组转换为字符串并使用 BigDecimal(String) 构造函数更快。
      参数：
      in - char 数组即字符来源。
      抛出：
      NumberFormatException - 如果 in 不是 BigDecimal 的有效表示。
      自从：
      1.5

    • BigDecimal

      public BigDecimal(char[] in, MathContext  mc)
      将 BigDecimal 的字符数组表示形式转换为 BigDecimal ，接受与 BigDecimal(String) 构造函数相同的字符序列，并根据上下文设置进行舍入。
      实现注意事项：
      如果字符序列已作为字符数组可用，则使用此构造函数比将 char 数组转换为字符串并使用 BigDecimal(String) 构造函数更快。
      参数：
      in - char 数组即字符来源。
      mc - 要使用的上下文。
      抛出：
      NumberFormatException - 如果 in 不是 BigDecimal 的有效表示。
      自从：
      1.5

    • BigDecimal

      public BigDecimal(String  val)
      将 BigDecimal 的字符串表示形式转换为 BigDecimal 。字符串表示形式由一个可选符号 '+' ( '\u002B' ) 或 '-' ('\u002D' ) 组成，后跟零个或多个十进制数字序列（“整数”），可选地后跟一个分数，可选地后跟一个指数。

      分数由小数点后跟零个或多个小数位组成。该字符串必须至少包含一位整数或分数。由符号、整数和分数组成的数称为有效数.

      指数由字符 'e' ('\u0065' ) 或 'E' ('\u0045' ) 后跟一位或多位十进制数字组成。

      更正式地说，此构造方法接受的字符串由以下语法描述：

      大十进制字符串：
      符号选择有效指数选择
      符号：
      +
      -
      有效数：
      IntegerPart . FractionPart选择
      . FractionPart
      IntegerPart
      整数部分：
      位数
      分数部分：
      位数
      指数：
      ExponentIndicator 有符号整数
      指数指标：
      e
      E
      有符号整数：
      符号选择位数
      数字：
      数字
      位数 位数
      数字：
      Character.isDigit(char) 返回 true 的任何字符，包括 0、1、2 ...

      返回的 BigDecimal 的小数位将是分数中的位数，如果字符串不包含小数点则为零，可根据任何指数进行调整；如果字符串包含指数，则从比例中减去指数。结果比例的值必须介于 Integer.MIN_VALUE 和 Integer.MAX_VALUE 之间（含）。

      字符到数字的映射由 Character.digit(char, int) 提供，设置为转换为基数 10。字符串不得包含任何无关字符（例如空格）。

      示例：
      返回的BigDecimal的值等于有效数× 10 指数.对于左侧的每个字符串，结果表示 [BigInteger , scale ] 显示在右侧。

       "0"      [0,0]
 "0.00"     [0,2]
 "123"     [123,0]
 "-123"     [-123,0]
 "1.23E3"    [123,-1]
 "1.23E+3"   [123,-1]
 "12.3E+7"   [123,-6]
 "12.0"     [120,1]
 "12.3"     [123,1]
 "0.00123"   [123,5]
 "-1.23E-12"  [-123,14]
 "1234.5E-4"  [12345,5]
 "0E+7"     [0,-7]
 "-0"      [0,0]
      API 注意：
      对于 float 和 double NaN 和 ±Infinity 以外的值，此构造函数与 Float.toString(float) 和 Double.toString(double) 返回的值兼容。这通常是将 float 或 double 转换为 BigDecimal 的首选方法，因为它不会受到 BigDecimal(double) 构造函数的不可预测性的影响。
      参数：
      val - BigDecimal 的字符串表示形式。
      抛出：
      NumberFormatException - 如果 val 不是 BigDecimal 的有效表示。

    • BigDecimal

      public BigDecimal(String  val, MathContext  mc)
      将 BigDecimal 的字符串表示形式转换为 BigDecimal ，接受与 BigDecimal(String) 构造函数相同的字符串，并根据上下文设置进行舍入。
      参数：
      val - BigDecimal 的字符串表示形式。
      mc - 要使用的上下文。
      抛出：
      NumberFormatException - 如果 val 不是 BigDecimal 的有效表示。
      自从：
      1.5

    • BigDecimal

      public BigDecimal(double val)
      将 double 转换为 BigDecimal，这是 double 的二进制浮点值的精确十进制表示。返回的 BigDecimal 的小数位数是使 (10scale × val) 为整数的最小值。

      笔记：

      1. 此构造函数的结果可能有些不可预测。人们可能会假设在 Java 中编写 new BigDecimal(0.1) 会创建一个 BigDecimal，它正好等于 0.1（未缩放的值为 1，缩放比例为 1），但它实际上等于 0.10000000000000000055511151231257827021181583404541015625。这是因为 0.1 不能完全表示为 double（或者，就此而言，表示为任何有限长度的二进制小数）。因此，传递给构造函数 in 的值并不完全等于 0.1，尽管有表象。
      2. 另一方面，String 构造函数是完全可预测的：编写 new BigDecimal("0.1") 创建一个 BigDecimal，它是 exactly 等于 0.1，正如人们所期望的那样。因此，一般建议优先使用字符串构造器。
      3. 当 double 必须用作 BigDecimal 的源时，请注意此构造函数提供了精确转换；它与使用 Double.toString(double) 方法然后使用 BigDecimal(String) 构造函数将 double 转换为 String 的结果不同。要获得该结果，请使用 static valueOf(double) 方法。
      参数：
      val - double 要转换为 BigDecimal 的值。
      抛出：
      NumberFormatException - 如果 val 是无穷大或 NaN。

    • BigDecimal

      public BigDecimal(double val, MathContext  mc)
      将 double 翻译成 BigDecimal ，根据上下文设置进行舍入。 BigDecimal 的标度是使 (10scale × val) 为整数的最小值。

      该构造函数的结果可能有些不可预测，通常不推荐使用；请参阅 BigDecimal(double) 构造函数下的注释。

      参数：
      val - double 要转换为 BigDecimal 的值。
      mc - 要使用的上下文。
      抛出：
      NumberFormatException - 如果 val 是无穷大或 NaN。
      自从：
      1.5

    • BigDecimal

      public BigDecimal(BigInteger  val)
      将 BigInteger 翻译成 BigDecimal 。 BigDecimal 的比例为零。
      参数：
      val - BigInteger 要转换为 BigDecimal 的值。

    • BigDecimal

      public BigDecimal(BigInteger  val, MathContext  mc)
      根据上下文设置将 BigInteger 转换为 BigDecimal 舍入。 BigDecimal 的比例为零。
      参数：
      val - BigInteger 要转换为 BigDecimal 的值。
      mc - 要使用的上下文。
      自从：
      1.5

    • BigDecimal

      public BigDecimal(BigInteger  unscaledVal, int scale)
      将 BigInteger 未缩放值和 int 缩放转换为 BigDecimal。 BigDecimal 的值为 (unscaledVal × 10-scale)。
      参数：
      unscaledVal - BigDecimal 的未缩放值。
      scale - BigDecimal 的规模。

    • BigDecimal

      public BigDecimal(BigInteger  unscaledVal, int scale, MathContext  mc)
      将 BigInteger unscaled 值和 int scale 转换为 BigDecimal ，根据上下文设置进行舍入。 BigDecimal 的值为 (unscaledVal × 10-scale)，根据 precision 和舍入模式设置进行舍入。
      参数：
      unscaledVal - BigDecimal 的未缩放值。
      scale - BigDecimal 的规模。
      mc - 要使用的上下文。
      自从：
      1.5

    • BigDecimal

      public BigDecimal(int val)
      将 int 翻译成 BigDecimal 。 BigDecimal 的比例为零。
      参数：
      val - int 值要转换为 BigDecimal 。
      自从：
      1.5

    • BigDecimal

      public BigDecimal(int val, MathContext  mc)
      将 int 翻译成 BigDecimal ，根据上下文设置进行舍入。 BigDecimal 的比例在任何舍入之前为零。
      参数：
      val - int 值要转换为 BigDecimal 。
      mc - 要使用的上下文。
      自从：
      1.5

    • BigDecimal

      public BigDecimal(long val)
      将 long 翻译成 BigDecimal 。 BigDecimal 的比例为零。
      参数：
      val - long 值要转换为 BigDecimal。
      自从：
      1.5

    • BigDecimal

      public BigDecimal(long val, MathContext  mc)
      将 long 翻译成 BigDecimal ，根据上下文设置进行舍入。 BigDecimal 的比例在任何舍入之前为零。
      参数：
      val - long 值要转换为 BigDecimal。
      mc - 要使用的上下文。
      自从：
      1.5

  • 方法详情

    • valueOf

      public static BigDecimal  valueOf(long unscaledVal, int scale)
      将 long 未缩放值和 int 缩放转换为 BigDecimal。
      API 注意：
      此静态工厂方法优先于 (long, int) 构造函数提供，因为它允许重用常用的 BigDecimal 值。
      参数：
      unscaledVal - BigDecimal 的未缩放值。
      scale - BigDecimal 的规模。
      返回：
      一个 BigDecimal 其值为 (unscaledVal × 10-scale) 。

    • valueOf

      public static BigDecimal  valueOf(long val)
      将 long 值转换为标度为零的 BigDecimal。
      API 注意：
      此静态工厂方法优先于 (long) 构造函数提供，因为它允许重用常用的 BigDecimal 值。
      参数：
      val - BigDecimal 的值。
      返回：
      一个 BigDecimal 其值为 val 。

    • valueOf

      public static BigDecimal  valueOf(double val)
      使用 Double.toString(double) 方法提供的 double 的规范字符串表示将 double 转换为 BigDecimal。
      API 注意：
      这通常是将 double（或 float）转换为 BigDecimal 的首选方法，因为返回的值等于从使用 Double.toString(double) 的结果构造 BigDecimal 的结果。
      参数：
      val - double 转换为 BigDecimal。
      返回：
      BigDecimal 的值等于或约等于 val 的值。
      抛出：
      NumberFormatException - 如果 val 是无穷大或 NaN。
      自从：
      1.5

    • add

      public BigDecimal  add(BigDecimal  augend)
      返回值为 (this + augend) 且比例为 max(this.scale(), augend.scale()) 的 BigDecimal。
      参数：
      augend - 要添加到此 BigDecimal 的值。
      返回：
      this + augend

    • add

      public BigDecimal  add(BigDecimal  augend, MathContext  mc)
      返回值为 (this + augend) 的 BigDecimal，根据上下文设置四舍五入。如果任一数字为零且精度设置为非零，则将另一个数字（必要时四舍五入）用作结果。
      参数：
      augend - 要添加到此 BigDecimal 的值。
      mc - 要使用的上下文。
      返回：
      this + augend ，根据需要四舍五入。
      自从：
      1.5

    • subtract

      public BigDecimal  subtract(BigDecimal  subtrahend)
      返回值为 (this - subtrahend) 且标度为 max(this.scale(), subtrahend.scale()) 的 BigDecimal。
      参数：
      subtrahend - 要从此 BigDecimal 中减去的值。
      返回：
      this - subtrahend

    • subtract

      public BigDecimal  subtract(BigDecimal  subtrahend, MathContext  mc)
      返回值为 (this - subtrahend) 的 BigDecimal，根据上下文设置四舍五入。如果 subtrahend 为零，则将其用作结果，必要时四舍五入。如果这是零，那么结果是 subtrahend.negate(mc) 。
      参数：
      subtrahend - 要从此 BigDecimal 中减去的值。
      mc - 要使用的上下文。
      返回：
      this - subtrahend ，根据需要四舍五入。
      自从：
      1.5

    • multiply

      public BigDecimal  multiply(BigDecimal  multiplicand)
      返回值为 (this × multiplicand) 且比例为 (this.scale() + multiplicand.scale()) 的 BigDecimal。
      参数：
      multiplicand - 要乘以这个 BigDecimal 的值。
      返回：
      this * multiplicand

    • multiply

      public BigDecimal  multiply(BigDecimal  multiplicand, MathContext  mc)
      返回值为 (this × multiplicand) 的 BigDecimal，根据上下文设置四舍五入。
      参数：
      multiplicand - 要乘以这个 BigDecimal 的值。
      mc - 要使用的上下文。
      返回：
      this * multiplicand ，根据需要四舍五入。
      自从：
      1.5

    • divide

      @Deprecated (since ="9") public BigDecimal  divide(BigDecimal  divisor, int scale, int roundingMode)
      已弃用。
      应优先使用方法 divide(BigDecimal, int, RoundingMode) 而不是此遗留方法。
      返回一个 BigDecimal ，其值为 (this / divisor) ，其比例为指定值。如果必须执行舍入以生成具有指定比例的结果，则应用指定的舍入模式。
      参数：
      divisor - 此 BigDecimal 要除以的值。
      scale - 要返回的 BigDecimal 商的比例。
      roundingMode - 要应用的舍入模式。
      返回：
      this / divisor
      抛出：
      ArithmeticException - 如果 divisor 为零，则 roundingMode==ROUND_UNNECESSARY 和指定的比例不足以准确表示除法的结果。
      IllegalArgumentException - 如果 roundingMode 不代表有效的舍入模式。
      参见：

    • divide

      public BigDecimal  divide(BigDecimal  divisor, int scale, RoundingMode  roundingMode)
      返回一个 BigDecimal ，其值为 (this / divisor) ，其比例为指定值。如果必须执行舍入以生成具有指定比例的结果，则应用指定的舍入模式。
      参数：
      divisor - 此 BigDecimal 要除以的值。
      scale - 要返回的 BigDecimal 商的比例。
      roundingMode - 要应用的舍入模式。
      返回：
      this / divisor
      抛出：
      ArithmeticException - 如果 divisor 为零，则 roundingMode==RoundingMode.UNNECESSARY 和指定的比例不足以准确表示除法的结果。
      自从：
      1.5

    • divide

      @Deprecated (since ="9") public BigDecimal  divide(BigDecimal  divisor, int roundingMode)
      已弃用。
      应优先使用方法 divide(BigDecimal, RoundingMode) 而不是此遗留方法。
      返回值为 (this / divisor) 且比例为 this.scale() 的 BigDecimal。如果必须执行舍入以生成具有给定比例的结果，则应用指定的舍入模式。
      参数：
      divisor - 此 BigDecimal 要除以的值。
      roundingMode - 要应用的舍入模式。
      返回：
      this / divisor
      抛出：
      ArithmeticException - 如果 divisor==0 或 roundingMode==ROUND_UNNECESSARY 和 this.scale() 不足以准确表示除法结果。
      IllegalArgumentException - 如果 roundingMode 不代表有效的舍入模式。
      参见：

    • divide

      public BigDecimal  divide(BigDecimal  divisor, RoundingMode  roundingMode)
      返回值为 (this / divisor) 且比例为 this.scale() 的 BigDecimal。如果必须执行舍入以生成具有给定比例的结果，则应用指定的舍入模式。
      参数：
      divisor - 此 BigDecimal 要除以的值。
      roundingMode - 要应用的舍入模式。
      返回：
      this / divisor
      抛出：
      ArithmeticException - 如果 divisor==0 或 roundingMode==RoundingMode.UNNECESSARY 和 this.scale() 不足以准确表示除法结果。
      自从：
      1.5

    • divide

      public BigDecimal  divide(BigDecimal  divisor)
      返回一个 BigDecimal ，其值为 (this / divisor) ，其首选比例为 (this.scale() - divisor.scale()) ；如果无法表示确切的商（因为它有一个不终止的十进制扩展），则会抛出一个 ArithmeticException。
      参数：
      divisor - 此 BigDecimal 要除以的值。
      返回：
      this / divisor
      抛出：
      ArithmeticException - 如果精确商没有终止小数扩展，包括除以零
      自从：
      1.5

    • divide

      public BigDecimal  divide(BigDecimal  divisor, MathContext  mc)
      返回值为 (this / divisor) 的 BigDecimal，根据上下文设置四舍五入。
      参数：
      divisor - 此 BigDecimal 要除以的值。
      mc - 要使用的上下文。
      返回：
      this / divisor ，根据需要四舍五入。
      抛出：
      ArithmeticException - 如果结果不准确但舍入模式为 UNNECESSARY 或 mc.precision == 0 并且商具有不终止的小数扩展，包括除以零
      自从：
      1.5

    • divideToIntegralValue

      public BigDecimal  divideToIntegralValue(BigDecimal  divisor)
      返回一个 BigDecimal，其值是商 (this / divisor) 向下舍入的整数部分。结果的首选比例是 (this.scale() - divisor.scale()) 。
      参数：
      divisor - 此 BigDecimal 要除以的值。
      返回：
      this / divisor 的整数部分。
      抛出：
      ArithmeticException - 如果 divisor==0
      自从：
      1.5

    • divideToIntegralValue

      public BigDecimal  divideToIntegralValue(BigDecimal  divisor, MathContext  mc)
      返回一个 BigDecimal，其值为 (this / divisor) 的整数部分。由于精确商的整数部分不依赖于舍入模式，因此舍入模式不会影响此方法返回的值。结果的首选比例是 (this.scale() - divisor.scale()) 。如果精确商的整数部分需要多于 mc.precision 位，则抛出 ArithmeticException。
      参数：
      divisor - 此 BigDecimal 要除以的值。
      mc - 要使用的上下文。
      返回：
      this / divisor 的整数部分。
      抛出：
      ArithmeticException - 如果 divisor==0
      ArithmeticException - 如果 mc.precision > 0 并且结果需要超过 mc.precision 位的精度。
      自从：
      1.5

    • remainder

      public BigDecimal  remainder(BigDecimal  divisor)
      返回值为 (this % divisor) 的 BigDecimal。

      余数由 this.subtract(this.divideToIntegralValue(divisor).multiply(divisor)) 给出。请注意，这是 not 模运算（结果可能为负）。

      参数：
      divisor - 此 BigDecimal 要除以的值。
      返回：
      this % divisor .
      抛出：
      ArithmeticException - 如果 divisor==0
      自从：
      1.5

    • remainder

      public BigDecimal  remainder(BigDecimal  divisor, MathContext  mc)
      返回值为 (this % divisor) 的 BigDecimal，根据上下文设置四舍五入。 MathContext 设置会影响用于计算余数的隐式除法。根据定义，余数计算本身是精确的。因此，余数可能包含多于 mc.getPrecision() 个数字。

      余数由 this.subtract(this.divideToIntegralValue(divisor, mc).multiply(divisor)) 给出。请注意，这不是模运算（结果可能为负）。

      参数：
      divisor - 此 BigDecimal 要除以的值。
      mc - 要使用的上下文。
      返回：
      this % divisor ，根据需要四舍五入。
      抛出：
      ArithmeticException - 如果 divisor==0
      ArithmeticException - 如果结果不准确但舍入模式为 UNNECESSARY 或 mc.precision > 0 并且 this.divideToIntegralValue(divisor) 的结果需要超过 mc.precision 位的精度。
      自从：
      1.5
      参见：

    • divideAndRemainder

      public BigDecimal [] divideAndRemainder(BigDecimal  divisor)
      返回一个二元素 BigDecimal 数组，其中包含 divideToIntegralValue 的结果，后跟两个操作数上的 remainder 的结果。

      请注意，如果同时需要整数商和余数，则此方法比分别使用 divideToIntegralValue 和 remainder 方法更快，因为除法只需执行一次。

      参数：
      divisor - 将此 BigDecimal 除以的值，并计算余数。
      返回：
      两个元素 BigDecimal 数组：商（ divideToIntegralValue 的结果）是初始元素，余数是最终元素。
      抛出：
      ArithmeticException - 如果 divisor==0
      自从：
      1.5
      参见：

    • divideAndRemainder

      public BigDecimal [] divideAndRemainder(BigDecimal  divisor, MathContext  mc)
      返回一个双元素 BigDecimal 数组，其中包含 divideToIntegralValue 的结果，后跟 remainder 对根据上下文设置舍入计算的两个操作数的结果。

      请注意，如果同时需要整数商和余数，则此方法比分别使用 divideToIntegralValue 和 remainder 方法更快，因为除法只需执行一次。

      参数：
      divisor - 将此 BigDecimal 除以的值，并计算余数。
      mc - 要使用的上下文。
      返回：
      两个元素 BigDecimal 数组：商（ divideToIntegralValue 的结果）是初始元素，余数是最终元素。
      抛出：
      ArithmeticException - 如果 divisor==0
      ArithmeticException - 如果结果不准确但舍入模式为 UNNECESSARY 或 mc.precision > 0 并且 this.divideToIntegralValue(divisor) 的结果需要超过 mc.precision 位的精度。
      自从：
      1.5
      参见：

    • sqrt

      public BigDecimal  sqrt(MathContext  mc)
      返回 this 的平方根的近似值，根据上下文设置进行舍入。

      返回结果的首选比例等于 this.scale()/2 。返回结果的值始终在所讨论精度的精确十进制值的 1 ulp 范围内。如果舍入模式为 HALF_UP 、 HALF_DOWN 或 HALF_EVEN ，则结果在精确十进制值的二分之一 ulp 范围内。

      特例：

      • 根据上述一般规则，在数值上等于 ZERO 的数字的平方根在数值上等于 ZERO 并具有首选标度。特别是，对于 ZERO ， ZERO.sqrt(mc).equals(ZERO) 以任何 MathContext 作为参数为真。
      参数：
      mc - 要使用的上下文。
      返回：
      this 的平方根。
      抛出：
      ArithmeticException - 如果 this 小于零。
      ArithmeticException - 如果请求精确结果 (mc.getPrecision()==0) 并且精确结果没有有限小数展开
      ArithmeticException - 如果是 (mc.getRoundingMode()==RoundingMode.UNNECESSARY ) 并且准确的结果不能放在 mc.getPrecision() 位中。
      自从：
      9
      参见：

    • pow

      public BigDecimal  pow(int n)
      返回值为 (thisn) 的 BigDecimal ，功率计算精确到无限精度。

      参数 n 必须在 0 到 999999999（含）范围内。 ZERO.pow(0) 返回 ONE 。请注意，未来的版本可能会扩大此方法的允许指数范围。

      参数：
      n - 将此 BigDecimal 提升到的权力。
      返回：
      thisn
      抛出：
      ArithmeticException - 如果 n 超出范围。
      自从：
      1.5

    • pow

      public BigDecimal  pow(int n, MathContext  mc)
      返回值为 (thisn) 的 BigDecimal。当前实现使用 ANSI 标准 X3.274-1996 中定义的核心算法，并根据上下文设置进行舍入。通常，返回的数值在所选精度的精确数值的两个 ulp 以内。请注意，未来的版本可能会使用不同的算法，并降低允许的误差界限并增加允许的指数范围。

      X3.274-1996算法是：

      • 抛出 ArithmeticException 异常，如果
        • abs(n) > 999999999
        • mc.precision == 0 和 n < 0
        • mc.precision > 0 和 n 有超过 mc.precision 个十进制数字
      • 如果 n 为零，即使 this 为零，也会返回 ONE ，否则
        • 如果 n 为正，则通过重复平方技术将结果计算到单个累加器中。与累加器的单独乘法使用与 mc 中相同的数学上下文设置，除了精度增加到 mc.precision + elength + 1，其中 elength 是 n 中的小数位数。
        • 如果 n 为负，则计算结果如同 n 为正；然后使用上面指定的工作精度将该值一分为二。
        • 然后将正例或负例的最终值四舍五入为目标精度。
      参数：
      n - 将此 BigDecimal 提升到的权力。
      mc - 要使用的上下文。
      返回：
      thisn使用ANSI标准X3.274-1996算法
      抛出：
      ArithmeticException - 如果结果不准确但舍入模式为 UNNECESSARY 或 n 超出范围。
      自从：
      1.5

    • abs

      public BigDecimal  abs()
      返回一个 BigDecimal ，它的值是这个 BigDecimal 的绝对值，它的比例是 this.scale() 。
      返回：
      abs(this)

    • abs

      public BigDecimal  abs(MathContext  mc)
      返回一个 BigDecimal ，其值是此 BigDecimal 的绝对值，根据上下文设置进行舍入。
      参数：
      mc - 要使用的上下文。
      返回：
      abs(this) ，根据需要四舍五入。
      自从：
      1.5

    • negate

      public BigDecimal  negate()
      返回值为 (-this) 且比例为 this.scale() 的 BigDecimal。
      返回：
      -this .

    • negate

      public BigDecimal  negate(MathContext  mc)
      返回值为 (-this) 的 BigDecimal，根据上下文设置四舍五入。
      参数：
      mc - 要使用的上下文。
      返回：
      -this ，根据需要四舍五入。
      自从：
      1.5

    • plus

      public BigDecimal  plus()
      返回值为 (+this) 且比例为 this.scale() 的 BigDecimal。

      此方法仅返回此 BigDecimal 以与一元减法 negate() 对称。

      返回：
      this .
      自从：
      1.5
      参见：

    • plus

      public BigDecimal  plus(MathContext  mc)
      返回值为 (+this) 的 BigDecimal，根据上下文设置四舍五入。

      此方法的效果与round(MathContext) 方法的效果相同。

      参数：
      mc - 要使用的上下文。
      返回：
      this ，根据需要四舍五入。零结果的比例为 0。
      自从：
      1.5
      参见：

    • signum

      public int signum()
      返回此 BigDecimal 的符号函数。
      返回：
      -1、0 或 1，因为此 BigDecimal 的值为负、零或正。

    • scale

      public int scale()
      返回scale这个 BigDecimal 。如果为零或正数，则小数位数是小数点右边的位数。如果为负数，则将数字的未缩放值乘以 10 的缩放负数次方。例如，-3 的比例表示未缩放的值乘以 1000。
      返回：
      这个 BigDecimal 的规模。

    • precision

      public int precision()
      返回precision这个 BigDecimal 。 （精度是未缩放值中的位数。）

      零值的精度为 1。

      返回：
      这个 BigDecimal 的精度。
      自从：
      1.5

    • unscaledValue

      public BigInteger  unscaledValue()
      返回一个 BigInteger，其值为未缩放的值这个 BigDecimal 。 （计算 (this * 10this.scale()) 。）
      返回：
      这个 BigDecimal 的未缩放值。
      自从：
      1.2

    • round

      public BigDecimal  round(MathContext  mc)
      返回根据 MathContext 设置四舍五入的 BigDecimal。如果精度设置为 0，则不进行舍入。

      此方法的效果与plus(MathContext) 方法的效果相同。

      参数：
      mc - 要使用的上下文。
      返回：
      a BigDecimal 根据 MathContext 设置四舍五入。
      自从：
      1.5
      参见：

    • setScale

      public BigDecimal  setScale(int newScale, RoundingMode  roundingMode)
      返回一个 BigDecimal，其标度为指定值，其未标度值是通过将此 BigDecimal 的未标度值乘以或除以 10 的适当幂来确定的，以保持其整体值。如果通过操作缩小比例，则必须除以（而不是乘以）未缩放的值，并且可能会更改该值；在这种情况下，指定的舍入模式应用于除法。
      API 注意：
      由于 BigDecimal 对象是不可变的，因此调用此方法会导致原始对象被修改，这与将方法命名为 setX mutate field 的通常约定相反X .相反，setScale 返回一个具有适当比例的对象；返回的对象可能是也可能不是新分配的。
      参数：
      newScale - 要返回的 BigDecimal 值的比例。
      roundingMode - 要应用的舍入模式。
      返回：
      一个 BigDecimal ，其标度为指定值，其未标度值通过将此 BigDecimal 的未标度值乘以或除以 10 的适当幂来确定，以保持其整体值。
      抛出：
      ArithmeticException - 如果 roundingMode==UNNECESSARY 和指定的缩放操作需要舍入。
      自从：
      1.5
      参见：

    • setScale

      @Deprecated (since ="9") public BigDecimal  setScale(int newScale, int roundingMode)
      已弃用。
      应优先使用方法 setScale(int, RoundingMode) 而不是此遗留方法。
      返回一个 BigDecimal，其标度为指定值，其未标度值是通过将此 BigDecimal 的未标度值乘以或除以 10 的适当幂来确定的，以保持其整体值。如果通过操作缩小比例，则必须除以（而不是乘以）未缩放的值，并且可能会更改该值；在这种情况下，指定的舍入模式应用于除法。
      API 注意：
      由于 BigDecimal 对象是不可变的，因此调用此方法会导致原始对象被修改，这与将方法命名为 setX mutate field 的通常约定相反X .相反，setScale 返回一个具有适当比例的对象；返回的对象可能是也可能不是新分配的。
      参数：
      newScale - 要返回的 BigDecimal 值的比例。
      roundingMode - 要应用的舍入模式。
      返回：
      一个 BigDecimal ，其标度为指定值，其未标度值通过将此 BigDecimal 的未标度值乘以或除以 10 的适当幂来确定，以保持其整体值。
      抛出：
      ArithmeticException - 如果 roundingMode==ROUND_UNNECESSARY 和指定的缩放操作需要舍入。
      IllegalArgumentException - 如果 roundingMode 不代表有效的舍入模式。
      参见：

    • setScale

      public BigDecimal  setScale(int newScale)
      返回一个 BigDecimal ，其比例为指定值，并且其值在数值上等于此 BigDecimal 的。如果不可能，则抛出 ArithmeticException。

      此调用通常用于增加比例，在这种情况下，可以保证存在指定比例和正确值的 BigDecimal。如果调用者知道 BigDecimal 在其小数部分末尾有足够多的零（即，其整数值的十倍）以允许在不更改其值的情况下重新缩放，则该调用也可用于减小比例。

      此方法返回与 setScale 的双参数版本相同的结果，但在不相关的情况下为调用者省去了指定舍入模式的麻烦。

      API 注意：
      由于 BigDecimal 对象是不可变的，因此调用此方法会 not 导致原始对象被修改，这与具有名为 setX mutate 字段的方法的通常约定相反X .相反，setScale 返回一个具有适当比例的对象；返回的对象可能是也可能不是新分配的。
      参数：
      newScale - 要返回的 BigDecimal 值的比例。
      返回：
      一个 BigDecimal ，其标度为指定值，其未标度值通过将此 BigDecimal 的未标度值乘以或除以 10 的适当幂来确定，以保持其整体值。
      抛出：
      ArithmeticException - 如果指定的缩放操作需要舍入。
      参见：

    • movePointLeft

      public BigDecimal  movePointLeft(int n)
      返回一个 BigDecimal 等同于小数点向左移动 n 位的这个。如果 n 为非负数，则调用仅将 n 添加到比例中。如果 n 为负，则调用等同于 movePointRight(-n) 。此调用返回的 BigDecimal 具有值 (this × 10-n) 和比例 max(this.scale()+n, 0) 。
      参数：
      n - 小数点向左移动的位数。
      返回：
      一个 BigDecimal 相当于这个小数点向左移动了 n 位。
      抛出：
      ArithmeticException - 如果比例溢出。

    • movePointRight

      public BigDecimal  movePointRight(int n)
      返回一个 BigDecimal 等同于小数点向右移动 n 位的这个。如果 n 为非负数，则调用仅从比例中减去 n。如果 n 为负，则调用等同于 movePointLeft(-n) 。此调用返回的 BigDecimal 具有值 (this × 10n) 和比例 max(this.scale()-n, 0) 。
      参数：
      n - 小数点向右移动的位数。
      返回：
      一个 BigDecimal 相当于这个小数点向右移动了 n 位。
      抛出：
      ArithmeticException - 如果比例溢出。

    • scaleByPowerOfTen

      public BigDecimal  scaleByPowerOfTen(int n)
      返回一个 BigDecimal，其数值等于 (this * 10n).结果的小数位数是 (this.scale() - n) 。
      参数：
      n - 十的指数幂
      返回：
      一个 BigDecimal，其数值等于 (this * 10n)
      抛出：
      ArithmeticException - 如果比例超出 32 位整数的范围。
      自从：
      1.5

    • stripTrailingZeros

      public BigDecimal  stripTrailingZeros()
      返回一个 BigDecimal，它在数值上等于这个，但从表示中删除了所有尾随零。例如，从 BigDecimal 值 600.0 中去除尾随零，其中 [BigInteger , scale ] 组件等于 [6000, 1]，产生 6E2，其中 [BigInteger , scale ] 组件等于 [6, -2]。如果此 BigDecimal 在数值上等于零，则返回 BigDecimal.ZERO。
      返回：
      一个数值上相等的 BigDecimal，删除了任何尾随零。
      抛出：
      ArithmeticException - 如果比例溢出。
      自从：
      1.5

    • compareTo

      public int compareTo(BigDecimal  val)
      将此 BigDecimal 与指定的 BigDecimal 在数值上进行比较。此方法认为值相等但比例不同（如 2.0 和 2.00）的两个 BigDecimal 对象相等。这些值在同一队列.此方法优先于六个布尔比较运算符（<、==、>、>=、!=、<=）中的每一个的单独方法。执行这些比较的建议习惯用法是： (x.compareTo(y) <op> 0) ，其中 <op> 是六个比较运算符之一。
      指定者：
      compareTo 在接口 Comparable<BigDecimal> 中
      API 注意：
      注意：此类具有与 equals 不一致的自然顺序。将此方法的结果与 0 进行比较的行为类似于检查 double 的 数量相等 值。
      参数：
      val - BigDecimal 要与此 BigDecimal 进行比较。
      返回：
      -1、0 或 1，因为此 BigDecimal 在数值上小于、等于或大于 val。

    • equals

      public boolean equals(Object  x)
      比较此 BigDecimal 与指定的 Object 是否相等。与 compareTo 不同，此方法仅在两个 BigDecimal 对象的值和比例相等时才认为它们相等。因此，当通过此方法进行比较时，2.0 不等于 2.00，因为前者的 [BigInteger , scale ] 组件等于 [20, 1]，而后者的组件等于 [200, 2]。
      重写：
      equals 在类 Object 中
      API 注意：
      一个例子显示了 2.0 和 2.00 如何在某些算术运算下not 可以相互替换，这两个表达式是：
      new BigDecimal("2.0" ).divide(BigDecimal.valueOf(3), HALF_UP) 计算结果为 0.7 和
      new BigDecimal("2.00").divide(BigDecimal.valueOf(3), HALF_UP) 的计算结果为 0.67。此方法的行为类似于检查 double 的 表示等价 值。
      参数：
      x - Object 要与此 BigDecimal 进行比较。
      返回：
      true 当且仅当指定的 Object 是一个 BigDecimal，其值和比例等于这个 BigDecimal 的。
      参见：

    • min

      public BigDecimal  min(BigDecimal  val)
      返回此 BigDecimal 和 val 的最小值。
      参数：
      val - 用于计算最小值的值。
      返回：
      BigDecimal 的值是 BigDecimal 和 val 中的较小者。如果它们相等，如 compareTo 方法所定义，则返回 this。
      参见：

    • max

      public BigDecimal  max(BigDecimal  val)
      返回此 BigDecimal 和 val 的最大值。
      参数：
      val - 用于计算最大值的值。
      返回：
      BigDecimal 的值是 BigDecimal 和 val 中的较大者。如果它们相等，如 compareTo 方法所定义，则返回 this。
      参见：

    • hashCode

      public int hashCode()
      返回此 BigDecimal 的哈希码。哈希码是作为这个 BigDecimal 的 未缩放的值 和 scale 的函数计算的。
      重写：
      hashCode 在类 Object 中
      API 注意：
      两个 BigDecimal 数值相等但比例不同的对象（如 2.0 和 2.00）通常 not 具有相同的哈希码。
      返回：
      这个 BigDecimal 的哈希码。
      参见：

    • toString

      public String  toString()
      返回此 BigDecimal 的字符串表示形式，如果需要指数，则使用科学记数法。

      BigDecimal 的标准规范字符串形式就像通过以下步骤一样创建：首先，使用字符 '0' 到 '9' 不带前导零（除非如果它的值为零，在这种情况下使用单个 '0' 字符）。

      接下来，一个调整指数被计算；这是取反的比例，加上转换后的未缩放值中的字符数，减去一个。即 -scale+(ulength-1) ，其中 ulength 是十进制数字中未缩放值的绝对值的长度（其precision).

      如果小数位数大于或等于零且调整后的指数大于或等于 -6 ，则将数字转换为字符形式，而不使用指数表示法。在这种情况下，如果小数位数为零，则不添加小数点，如果小数位数为正数，则插入小数点，小数位数指定小数点右侧的字符数。 '0' 个字符会根据需要添加到转换后的未缩放值的左侧。如果在此插入后小数点前没有字符，则在前面加上一个常规的 '0' 字符。

      否则（即，如果小数位数为负，或调整后的指数小于 -6 ），将使用指数表示法将数字转换为字符形式。在这种情况下，如果转换后的 BigInteger 有多个数字，则在第一个数字后插入一个小数点。然后将字符形式的指数后缀到转换后的未缩放值（可能插入小数点）；这包括字母 'E'，紧接着是转换为字符形式的调整指数。后者以十为底，使用字符 '0' 到 '9'，没有前导零，并且如果调整后的指数为负，则始终以符号字符 '-' ('\u002D' ) 为前缀，否则为 '+' ('\u002B' )）。

      最后，如果未缩放的值小于零，则整个字符串以减号字符 '-' ('\u002D') 为前缀。如果未缩放的值为零或正数，则没有符号字符作为前缀。

      示例：

      对于每个表示 [未缩放的值, scale] 在左边，结果字符串显示在右边。

       [123,0]   "123"
 [-123,0]   "-123"
 [123,-1]   "1.23E+3"
 [123,-3]   "1.23E+5"
 [123,1]   "12.3"
 [123,5]   "0.00123"
 [123,10]   "1.23E-8"
 [-123,12]  "-1.23E-10"
      笔记：
      1. 可区分的 BigDecimal 值与此转换的结果之间存在一对一的映射。也就是说，由于使用了 toString，每个可区分的 BigDecimal 值（未缩放的值和缩放）都具有唯一的字符串表示形式。如果使用 BigDecimal(String) 构造函数将该字符串表示形式转换回 BigDecimal，则将恢复原始值。
      2. 为给定数字生成的字符串始终相同；它不受locale的影响。这意味着它可以用作交换十进制数据的规范字符串表示，或用作哈希表的键等。区域设置敏感的数字格式和解析由 NumberFormat 类及其子类处理。
      3. toEngineeringString() 方法可用于以工程符号表示带指数的数字，setScale 方法可用于四舍五入 BigDecimal，使其小数点后的位数已知。
      4. 使用Character.forDigit 提供的数字到字符映射。
      重写：
      toString 在类 Object 中
      返回：
      这个 BigDecimal 的字符串表示。
      参见：

    • toEngineeringString

      public String  toEngineeringString()
      返回此 BigDecimal 的字符串表示形式，如果需要指数，则使用工程符号。

      返回表示 BigDecimal 的字符串，如 toString() 方法中所述，但如果使用指数表示法，则将 10 的幂调整为 3 的倍数（工程表示法），这样非零值的整数部分将在范围从 1 到 999。如果对零值使用指数表示法，则使用小数点和一个或两个小数零位，以便保留零值的小数位数。请注意，与 toString() 的输出不同，如果输出字符串正在使用 字符串构造器 转换回 BigDecimal ，则此方法的输出是 not 保证恢复此 BigDecimal 的相同 [integer, scale] 对。此方法的结果满足较弱的约束，即始终通过将字符串构造函数应用于方法的输出而产生数值相等的结果。

      返回：
      此 BigDecimal 的字符串表示形式，如果需要指数，则使用工程符号。
      自从：
      1.5

    • toPlainString

      public String  toPlainString()
      返回此 BigDecimal 的字符串表示形式，不带指数字段。对于具有正刻度的值，小数点右侧的位数用于指示刻度。对于具有零或负标度的值，生成的结果字符串就好像该值已转换为具有零标度的数值相等的值，并且就好像零标度值的所有尾随零都出现在结果中一样。如果未缩放的值小于零，则整个字符串以减号字符“-”('\u002D') 为前缀。如果未缩放的值为零或正数，则没有符号字符作为前缀。请注意，如果将此方法的结果传递给字符串构造器，则只需要恢复此BigDecimal的数值；新 BigDecimal 的表示可能具有不同的比例。特别是，如果此 BigDecimal 具有负标度，则此方法生成的字符串在由字符串构造函数处理时的标度将为零。 （此方法的行为类似于 1.4 和更早版本中的 toString 方法。）
      返回：
      不带指数字段的此 BigDecimal 的字符串表示形式。
      自从：
      1.5
      参见：

    • toBigInteger

      public BigInteger  toBigInteger()
      将此 BigDecimal 转换为 BigInteger 。这种转换类似于缩小原始转换从 double 到 long 如定义Java 语言规范这个 BigDecimal 的任何小数部分都将被丢弃。请注意，此转换可能会丢失有关 BigDecimal 值精度的信息。

      要在转换不准确时抛出异常（换句话说，如果丢弃了非零小数部分），请使用 toBigIntegerExact() 方法。

      返回：
      这 BigDecimal 转换为 BigInteger 。
      看Java 语言规范:
      5.1.3 缩小原始转换

    • toBigIntegerExact

      public BigInteger  toBigIntegerExact()
      将此 BigDecimal 转换为 BigInteger ，检查丢失的信息。如果此 BigDecimal 具有非零小数部分，则会抛出异常。
      返回：
      这 BigDecimal 转换为 BigInteger 。
      抛出：
      ArithmeticException - 如果 this 具有非零小数部分。
      自从：
      1.5

    • longValue

      public long longValue()
      将此 BigDecimal 转换为 long 。这种转换类似于缩小原始转换从 double 到 short 如定义Java 语言规范：这个 BigDecimal 的任何小数部分都将被丢弃，如果生成的“BigInteger”太大而无法放入 long，则仅返回低位 64 位。请注意，此转换可能会丢失有关此 BigDecimal 值的总体大小和精度的信息，并返回带有相反符号的结果。
      指定者：
      longValue 在类 Number 中
      返回：
      这个 BigDecimal 转换为 long 。
      看Java 语言规范:
      5.1.3 缩小原始转换

    • longValueExact

      public long longValueExact()
      将此 BigDecimal 转换为 long ，检查丢失的信息。如果此 BigDecimal 具有非零小数部分或超出 long 结果的可能范围，则抛出 ArithmeticException。
      返回：
      这个 BigDecimal 转换为 long 。
      抛出：
      ArithmeticException - 如果 this 具有非零小数部分，或者不适合 long 。
      自从：
      1.5

    • intValue

      public int intValue()
      将此 BigDecimal 转换为 int 。这种转换类似于缩小原始转换从 double 到 short 如定义Java 语言规范这个 BigDecimal 的任何小数部分都将被丢弃，如果生成的 "BigInteger " 太大而不适合 int ，则只返回低位 32 位。请注意，此转换可能会丢失有关此 BigDecimal 值的总体大小和精度的信息，并返回带有相反符号的结果。
      指定者：
      intValue 在类 Number 中
      返回：
      这个 BigDecimal 转换为 int 。
      看Java 语言规范:
      5.1.3 缩小原始转换

    • intValueExact

      public int intValueExact()
      将此 BigDecimal 转换为 int ，检查丢失的信息。如果此 BigDecimal 具有非零小数部分或超出 int 结果的可能范围，则抛出 ArithmeticException。
      返回：
      这个 BigDecimal 转换为 int 。
      抛出：
      ArithmeticException - 如果 this 具有非零小数部分，或者不适合 int 。
      自从：
      1.5

    • shortValueExact

      public short shortValueExact()
      将此 BigDecimal 转换为 short ，检查丢失的信息。如果此 BigDecimal 具有非零小数部分或超出 short 结果的可能范围，则抛出 ArithmeticException。
      返回：
      这 BigDecimal 转换为 short 。
      抛出：
      ArithmeticException - 如果 this 具有非零小数部分，或者不适合 short 。
      自从：
      1.5

    • byteValueExact

      public byte byteValueExact()
      将此 BigDecimal 转换为 byte ，检查丢失的信息。如果此 BigDecimal 具有非零小数部分或超出 byte 结果的可能范围，则抛出 ArithmeticException。
      返回：
      这个 BigDecimal 转换为 byte 。
      抛出：
      ArithmeticException - 如果 this 具有非零小数部分，或者不适合 byte 。
      自从：
      1.5

    • floatValue

      public float floatValue()
      将此 BigDecimal 转换为 float 。这种转换类似于缩小原始转换从 double 到 float 如定义Java 语言规范：如果这个 BigDecimal 的幅度太大而无法表示为 float ，它将被适当地转换为 Float.NEGATIVE_INFINITY 或 Float.POSITIVE_INFINITY 。请注意，即使返回值是有限的，此转换也会丢失有关 BigDecimal 值精度的信息。
      指定者：
      floatValue 在类 Number 中
      返回：
      这 BigDecimal 转换为 float 。
      看Java 语言规范:
      5.1.3 缩小原始转换

    • doubleValue

      public double doubleValue()
      将此 BigDecimal 转换为 double 。这种转换类似于缩小原始转换从 double 到 float 如定义Java 语言规范：如果这个 BigDecimal 的幅度太大表示为 double ，它将被适当地转换为 Double.NEGATIVE_INFINITY 或 Double.POSITIVE_INFINITY 。请注意，即使返回值是有限的，此转换也会丢失有关 BigDecimal 值精度的信息。
      指定者：
      doubleValue 在类 Number 中
      返回：
      这个 BigDecimal 转换为 double 。
      看Java 语言规范:
      5.1.3 缩小原始转换

    • ulp

      public BigDecimal  ulp()
      返回这个 BigDecimal 的 ulp 的大小，最后一个单位。非零 BigDecimal 值的 ulp 是该值与具有相同位数的下一个更大的 BigDecimal 值之间的正距离。零值的 ulp 在数值上等于 1，标度为 this。结果以与 this 相同的比例存储，因此零值和非零值的结果等于 [1, this.scale()] 。
      返回：
      this 的 ulp 的大小
      自从：
      1.5