Module java.base
Package java.math

Class BigDecimal

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

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

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

当使用精度设置为 0 的 MathContext 对象（例如，MathContext.UNLIMITED）提供时，算术操作是精确的，就像不带 MathContext 对象的算术方法一样。作为计算精确结果的推论，具有精度设置为 0 的 MathContext 对象的舍入模式设置不起作用，因此无关紧要。在除法的情况下，精确商可能具有无限长的小数展开；例如，1 除以 3。如果商具有非终止的小数展开并且操作被指定为返回精确结果，则会抛出 ArithmeticException。否则，将返回除法的精确结果，就像对其他操作一样。

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

由于相同的数值可以具有不同的表示（具有不同的标度），因此算术和舍入规则必须同时指定结果的数值和使用的标度。同一数值的不同表示称为同一 队列 的成员。 BigDecimal 的 自然顺序 将同一队列的成员视为相等。相反，equals 方法要求数值值和表示必须相同才能成立相等。对于具有不同表示的数值，诸如 scale 和 unscaledValue() 的方法的结果将有所不同。

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

对于所有算术运算符，操作被执行，就好像首先计算了一个精确的中间结果，然后根据需要将其舍入到由精度设置指定的位数（如果需要），使用所选的舍入模式。如果未返回精确结果，则会舍弃精确结果的某些数字位置。当舍入增加返回结果的幅度时，通过进位传播到领先的“9”数字位，可能会创建一个新的数字位置。例如，将值 999.9 四舍五入到三位数会数值上等于一千，表示为 100×101。在这种情况下，新的“1”是返回结果的领先数字位置。

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

除了逻辑精确结果外，每个算术操作都有一个用于表示结果的首选标度。每个操作的首选标度列在下表中。

算术操作结果的首选标度
操作 结果的首选标度
加法 max(被加数标度(), 加数标度())
减法 max(被减数标度(), 减数标度())
乘法 乘数标度() + 乘数标度()
除法 被除数标度() - 除数标度()
平方根 被开方数标度()/2
这些标度是返回精确算术结果的方法使用的标度；除非精确除法可能需要使用更大的标度，因为精确结果可能具有更多位数。例如，1/32 是 0.03125。

在舍入之前，逻辑精确中间结果的标度是该操作的首选标度。如果无法用 precision 位数表示精确数值结果，则舍入会选择要返回的数字集，并且结果的标度会从中间结果的标度减少到可以表示实际返回的 precision 位数的最小标度。如果精确结果最多可以用 precision 位数表示，则将返回与首选标度最接近的结果的表示。特别地，可以通过去除尾随零并减少标度来用三位数四舍五入，例如，使用 floor 舍入模式四舍五入到三位数，
19/100 = 0.19 // 整数=19，标度=2
但是
21/110 = 0.190 // 整数=190，标度=3

其他方法可能具有稍有不同的舍入语义。例如，使用 指定算法 的 pow 方法的结果有时可能与四舍五入的数学结果相差一个单位，即一个 ulp。

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

ArithmeticException。

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

null 对象引用时都会抛出 NullPointerException。

API注释:
如果在SortedMap中将BigDecimal对象用作键，或者在SortedSet中将其用作元素，则应谨慎，因为BigDecimal的自然排序与equals方法不一致。有关更多信息，请参阅Comparable，SortedMap或SortedSet。

与IEEE 754十进制算术的关系

从2008年修订版开始，《IEEE 754浮点算术标准》涵盖了十进制格式和操作。虽然IEEE 754定义的十进制算术与此类定义的算术有广泛的相似之处，但也存在显著差异。 BigDecimal和IEEE 754十进制算术共享的基本相似之处是计算操作的数学无限精确实数值，然后根据舍入策略将该实数映射到可表示的十进制浮点值。舍入策略称为BigDecimal的舍入模式，在IEEE 754-2019中称为舍入方向属性。当无法表示确切值时，舍入策略确定选择哪个包围确切值的两个可表示十进制值作为计算结果。两个系统还共享首选标度/首选指数的概念。

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

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

如果使用与IEEE 754十进制格式相对应的MathContext（例如decimal64或decimal128）来舍入所有起始值和中间操作，BigDecimal算术将最类似于IEEE 754十进制算术。如果超出了正在近似的IEEE 754格式的指数范围，则计算的数值可能会有所不同，因为MathContext不限制BigDecimal结果的标度。在BigDecimal算术中，会抛出ArithmeticException的操作包括生成NaN或确切无穷大，例如除以零。

自版本:
1.1
参见:

  • Field Details

    • 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
      Deprecated.
      Use RoundingMode.UP instead.
      四舍五入模式，远离零舍入。总是增加非零被舍弃分数的前一位数字。请注意，此舍入模式永远不会减少计算值的幅度。
      参见：

    • ROUND_DOWN

      @Deprecated(since="9") public static final int ROUND_DOWN
      Deprecated.
      Use RoundingMode.DOWN instead.
      四舍五入模式，向零舍入。从不增加被舍弃分数之前的数字（即截断）。请注意，此舍入模式永远不会增加计算值的幅度。
      参见：

    • ROUND_CEILING

      @Deprecated(since="9") public static final int ROUND_CEILING
      Deprecated.
      Use RoundingMode.CEILING instead.
      四舍五入模式，向正无穷舍入。如果BigDecimal为正，则行为类似于ROUND_UP；如果为负，则行为类似于ROUND_DOWN。请注意，此舍入模式永远不会减少计算值。
      参见：

    • ROUND_FLOOR

      @Deprecated(since="9") public static final int ROUND_FLOOR
      Deprecated.
      Use RoundingMode.FLOOR instead.
      四舍五入模式，向负无穷舍入。如果BigDecimal为正，则行为类似于ROUND_DOWN；如果为负，则行为类似于ROUND_UP。请注意，此舍入模式永远不会增加计算值。
      参见：

    • ROUND_HALF_UP

      @Deprecated(since="9") public static final int ROUND_HALF_UP
      Deprecated.
      Use RoundingMode.HALF_UP instead.
      四舍五入模式，向“最近邻居”舍入，除非两个邻居都等距，此时向上舍入。如果被舍弃的分数≥0.5，则行为类似于ROUND_UP；否则，行为类似于ROUND_DOWN。请注意，这是我们大多数人在小学时学到的舍入模式。
      参见：

    • ROUND_HALF_DOWN

      @Deprecated(since="9") public static final int ROUND_HALF_DOWN
      Deprecated.
      Use RoundingMode.HALF_DOWN instead.
      四舍五入模式，向“最近邻居”舍入，除非两个邻居都等距，此时向下舍入。如果被舍弃的分数>0.5，则行为类似于ROUND_UP；否则，行为类似于ROUND_DOWN。
      参见：

    • ROUND_HALF_EVEN

      @Deprecated(since="9") public static final int ROUND_HALF_EVEN
      Deprecated.
      Use RoundingMode.HALF_EVEN instead.
      四舍五入模式，向“最近邻居”舍入，除非两个邻居都等距，此时向偶数邻居舍入。如果被舍弃分数左侧的数字为奇数，则行为类似于ROUND_HALF_UP；如果为偶数，则行为类似于ROUND_HALF_DOWN。请注意，这是在一系列计算中重复应用时最小化累积误差的舍入模式。
      参见：

    • ROUND_UNNECESSARY

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

  • Constructor Details

    • 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'）后跟一个或多个十进制数字组成。

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

      BigDecimalString:
      符号可选 有效数字 指数可选
      符号:
      +
      -
      有效数字:
      整数部分 . 分数部分可选
      . 分数部分
      整数部分
      整数部分:
      数字
      分数部分:
      数字
      指数:
      指数指示符 有符号整数
      指数指示符:
      e
      E
      有符号整数:
      符号可选 数字
      数字:
      任何使Character.isDigit(char)返回true的字符，包括0、1、2...

      返回的BigDecimal的标度将是分数中的数字个数，如果字符串不包含小数点，则为零，受到任何指数调整的影响；如果字符串包含指数，则从标度中减去指数。结果标度的值必须介于Integer.MIN_VALUE和Integer.MAX_VALUE之间，包括这两个值。

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

      示例：
      返回的BigDecimal的值等于有效数字 × 10 指数。对于左侧的每个字符串，右侧显示了生成的表示形式[BigInteger, 标度]。

       "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，该BigDecimal是double的二进制浮点值的精确十进制表示。返回的BigDecimal的标度是最小值，使得(10scale × val)是一个整数。

      注意：

      1. 此构造函数的结果可能有些不可预测。有人可能会认为在Java中编写new BigDecimal(0.1)会创建一个精确等于0.1的BigDecimal（一个无标度值为1，标度为1），但实际上等于0.1000000000000000055511151231257827021181583404541015625。这是因为0.1不能精确表示为一个double（或者说，不能精确表示为任何有限长度的二进制分数）。因此，传递给构造函数的值并不完全等于0.1，尽管外表如此。
      2. 另一方面，String构造函数是完全可预测的：编写new BigDecimal("0.1")会创建一个BigDecimal，其确切等于0.1，正如人们所期望的那样。因此，通常建议优先使用String构造函数而不是这个构造函数。
      3. 当必须使用double作为BigDecimal的源时，请注意，此构造函数提供了精确的转换；它不会产生将double转换为String使用Double.toString(double)方法，然后使用BigDecimal(String)构造函数的结果。要获得该结果，请使用static valueOf(double)方法。
      参数：
      val - 要转换为BigDecimal的double值。
      抛出：
      NumberFormatException - 如果val是无穷大或NaN。

    • BigDecimal

      public BigDecimal(double val, MathContext mc)
      将一个double转换为BigDecimal，根据上下文设置进行四舍五入。返回的BigDecimal的标度是最小值，使得(10scale × val)是一个整数。

      此构造函数的结果可能有些不可预测，通常不建议使用；请参阅BigDecimal(double)构造函数下的注意事项。

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

    • BigDecimal

      public BigDecimal(BigInteger val)
      将一个BigInteger转换为BigDecimal。返回的BigDecimal的标度为零。
      参数：
      val - 要转换为BigDecimal的BigInteger值。

    • BigDecimal

      public BigDecimal(BigInteger val, MathContext mc)
      将一个BigInteger转换为BigDecimal，根据上下文设置进行四舍五入。返回的BigDecimal的标度为零。
      参数：
      val - 要转换为BigDecimal的BigInteger值。
      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无标度值和一个int标度转换为BigDecimal，根据上下文设置进行四舍五入。返回的BigDecimal的值为(unscaledVal × 10-scale)，根据precision和四舍五入模式设置进行四舍五入。
      参数：
      unscaledVal - BigDecimal的无标度值。
      scale - BigDecimal的标度。
      mc - 要使用的上下文。
      自版本：
      1.5

    • BigDecimal

      public BigDecimal(int val)
      将一个int转换为BigDecimal。返回的BigDecimal的标度为零。
      参数：
      val - 要转换为BigDecimal的int值。
      自版本：
      1.5

    • BigDecimal

      public BigDecimal(int val, MathContext mc)
      将一个int转换为BigDecimal，根据上下文设置进行四舍五入。在任何四舍五入之前，BigDecimal的标度为零。
      参数：
      val - 要转换为BigDecimal的int值。
      mc - 要使用的上下文。
      自版本：
      1.5

    • BigDecimal

      public BigDecimal(long val)
      将一个long转换为BigDecimal。返回的BigDecimal的标度为零。
      参数：
      val - 要转换为BigDecimal的long值。
      自版本：
      1.5

    • BigDecimal

      public BigDecimal(long val, MathContext mc)
      将一个long转换为BigDecimal，根据上下文设置进行四舍五入。在任何四舍五入之前，BigDecimal的标度为零。
      参数：
      val - 要转换为BigDecimal的long值。
      mc - 要使用的上下文。
      自版本：
      1.5

  • Method Details

    • valueOf

      public static BigDecimal valueOf(long unscaledVal, int scale)
      将一个long无标度值和一个int标度转换为BigDecimal。
      API注释：
      提供此静态工厂方法，而不是(long, int)构造函数，因为它允许重复使用频繁使用的BigDecimal值。
      参数：
      unscaledVal - BigDecimal的无标度值。
      scale - BigDecimal的标度。
      返回：
      一个值为(unscaledVal × 10-scale)的BigDecimal。

    • valueOf

      public static BigDecimal valueOf(long val)
      将一个long值转换为标度为零的BigDecimal。
      API注释：
      提供此静态工厂方法，而不是(long)构造函数，因为它允许重复使用频繁使用的BigDecimal值。
      参数：
      val - BigDecimal的值。
      返回：
      一个值为val的BigDecimal。

    • valueOf

      public static BigDecimal valueOf(double val)
      将一个double转换为BigDecimal，使用Double.toString(double)方法提供的double的规范字符串表示。
      API注释：
      这通常是将double（或float）转换为BigDecimal的首选方法，因为返回的值等于使用Double.toString(double)的结果构造BigDecimal的值。
      参数：
      val - 要转换为BigDecimal的double。
      返回：
      一个值等于或大致等于val的BigDecimal。
      抛出：
      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)
      Deprecated.
      The method divide(BigDecimal, int, RoundingMode) should be used in preference to this legacy method.
      返回一个值为(this / divisor)的BigDecimal，其标度如指定。如果必须进行舍入以生成具有指定标度的结果，则应用指定的舍入模式。
      参数:
      divisor - 要除以此BigDecimal的值。
      scale - 要返回的BigDecimal商的标度。
      roundingMode - 要应用的舍入模式。
      返回:
      this / divisor
      抛出:
      ArithmeticException - 如果divisor为零，roundingMode==ROUND_UNNECESSARY且指定的标度不足以精确表示除法的结果。
      IllegalArgumentException - 如果roundingMode不表示有效的舍入模式。
      参见:

    • divide

      public BigDecimal divide(BigDecimal divisor, int scale, RoundingMode roundingMode)
      返回一个值为(this / divisor)的BigDecimal，其标度如指定。如果必须进行舍入以生成具有指定标度的结果，则应用指定的舍入模式。
      参数:
      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)
      Deprecated.
      The method divide(BigDecimal, RoundingMode) should be used in preference to this legacy method.
      返回一个值为(this / divisor)的BigDecimal，其标度为this.scale()。如果必须进行舍入以生成具有给定标度的结果，则应用指定的舍入模式。
      参数:
      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)的BigDecimal，其标度为this.scale()。如果必须进行舍入以生成具有给定标度的结果，则应用指定的舍入模式。
      参数:
      divisor - 要除以此BigDecimal的值。
      roundingMode - 要应用的舍入模式。
      返回:
      this / divisor
      抛出:
      ArithmeticException - 如果divisor==0，或roundingMode==RoundingMode.UNNECESSARY且this.scale()不足以精确表示除法的结果。
      自版本:
      1.5

    • divide

      public BigDecimal divide(BigDecimal divisor)
      返回一个值为(this / divisor)的BigDecimal，其首选标度为(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)
      返回一个值为(this / divisor)的BigDecimal，向下舍入为商的整数部分。结果的首选标度为(this.scale() - divisor.scale())。
      参数:
      divisor - 要除以此BigDecimal的值。
      返回:
      this / divisor的整数部分。
      抛出:
      ArithmeticException - 如果divisor==0
      自版本:
      1.5

    • divideToIntegralValue

      public BigDecimal divideToIntegralValue(BigDecimal divisor, MathContext mc)
      返回一个值为(this / divisor)的BigDecimal的整数部分。由于精确商的整数部分不取决于舍入模式，因此舍入模式不会影响此方法返回的值。结果的首选标度为(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))给出。请注意，这不是模运算（结果可能为负数）。

      参数:
      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数组：商（divideToIntegralValue的结果）是初始元素，余数是最终元素。
      抛出:
      ArithmeticException - 如果divisor==0
      自版本:
      1.5
      参见:

    • divideAndRemainder

      public BigDecimal[] divideAndRemainder(BigDecimal divisor, MathContext mc)
      返回一个包含两个元素的BigDecimal数组，其中第一个元素是divideToIntegralValue的结果，第二个元素是根据上下文设置进行四舍五入后两个操作数上remainder的结果。

      请注意，如果需要整数商和余数，使用这个方法比分别使用divideToIntegralValue和remainder方法更快，因为只需要进行一次除法运算。

      参数:
      divisor - 用于除法运算和计算余数的值。
      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的BigDecimal。

      返回结果的首选标度等于this.scale()/2。返回结果的值始终在所选精度的精确十进制值的一个ulp范围内。如果舍入模式为HALF_UP、HALF_DOWN或HALF_EVEN，结果将在精确十进制值的一半ulp范围内。

      特殊情况：

      • 与ZERO数值相等的数的平方根在数值上等于ZERO，其首选标度遵循上述一般规则。特别地，对于ZERO，使用任何MathContext作为参数，ZERO.sqrt(mc).equals(ZERO)都为真。
      参数:
      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 - 要使用的上下文。
      返回:
      使用ANSI标准X3.274-1996算法的thisn
      抛出:
      ArithmeticException - 如果结果不精确但舍入模式为UNNECESSARY，或者n超出范围。
      自版本:
      1.5

    • abs

      public BigDecimal abs()
      返回一个值为此BigDecimal的绝对值，且标度为this.scale()的BigDecimal。
      返回:
      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的signum函数值。
      返回:
      如果此BigDecimal的值为负数，则返回-1；如果为零，则返回0；如果为正数，则返回1。

    • scale

      public int scale()
      返回此BigDecimal的标度。如果为零或正数，则标度是小数点右侧的数字个数。如果为负数，则数字的无标度值乘以10的负标度幂。例如，标度为-3表示无标度值乘以1000。
      返回:
      此BigDecimal的标度。

    • precision

      public int 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 - 要使用的上下文。
      返回：
      根据MathContext设置四舍五入的BigDecimal。
      自：
      1.5
      另请参阅：

    • setScale

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

    • setScale

      @Deprecated(since="9") public BigDecimal setScale(int newScale, int roundingMode)
      Deprecated.
      The method setScale(int, RoundingMode) should be used in preference to this legacy method.
      返回一个BigDecimal，其标度为指定值，其未缩放值由将此BigDecimal的未缩放值乘以或除以适当的十的幂来确定以保持其整体值。如果通过操作减少标度，则必须除以未缩放值（而不是乘以），并且值可能会更改；在这种情况下，将应用指定的舍入模式进行除法。
      API注释：
      由于BigDecimal对象是不可变的，因此调用此方法不会导致原始对象被修改，与通常的具有命名为setX的方法改变字段X的约定相反。相反，setScale返回一个具有适当标度的对象；返回的对象可能是新分配的，也可能不是。
      参数：
      newScale - 要返回的BigDecimal值的标度。
      roundingMode - 要应用的舍入模式。
      返回：
      一个BigDecimal，其标度为指定值，其未缩放值由将此BigDecimal的未缩放值乘以或除以适当的十的幂来确定以保持其整体值。
      抛出：
      ArithmeticException - 如果roundingMode==ROUND_UNNECESSARY且指定的缩放操作需要舍入。
      IllegalArgumentException - 如果roundingMode不表示有效的舍入模式。
      另请参阅：

    • setScale

      public BigDecimal setScale(int newScale)
      返回一个BigDecimal，其标度为指定值，其值与此BigDecimal的数值相等。如果不可能，则抛出ArithmeticException。

      通常用于增加标度，此时保证存在具有指定标度和正确值的BigDecimal。如果调用者知道BigDecimal的小数部分末尾有足够多的零（即，其整数值中的十因子）以允许重新缩放而不更改其值，则也可以使用此调用来减少标度。

      此方法返回与setScale的两个参数版本相同的结果，但在不涉及舍入模式的情况下节省了调用者的麻烦。

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

    • movePointLeft

      public BigDecimal movePointLeft(int n)
      返回一个BigDecimal，其等效于将小数点向左移动n位的此BigDecimal。如果n为非负数，则调用仅将n添加到标度。如果n为负数，则调用等效于movePointRight(-n)。此调用返回的BigDecimal的值为(this × 10-n)，标度为max(this.scale()+n, 0)。
      参数：
      n - 要将小数点向左移动的位数。
      返回：
      一个BigDecimal，其等效于将小数点向左移动n位的此BigDecimal。
      抛出：
      ArithmeticException - 如果标度溢出。

    • movePointRight

      public BigDecimal movePointRight(int n)
      返回一个BigDecimal，其等效于将小数点向右移动n位的此BigDecimal。如果n为非负数，则调用仅从标度中减去n。如果n为负数，则调用等效于movePointLeft(-n)。此调用返回的BigDecimal的值为(this × 10n)，标度为max(this.scale()-n, 0)。
      参数：
      n - 要将小数点向右移动的位数。
      返回：
      一个BigDecimal，其等效于将小数点向右移动n位的此BigDecimal。
      抛出：
      ArithmeticException - 如果标度溢出。

    • scaleByPowerOfTen

      public BigDecimal scaleByPowerOfTen(int n)
      返回一个数值等于（this * 10n）的BigDecimal。结果的标度为(this.scale() - n)。
      参数：
      n - 要按十的指数幂缩放的指数
      返回：
      一个数值等于（this * 10n）的BigDecimal
      抛出：
      ArithmeticException - 如果标度超出32位整数的范围。
      自：
      1.5

    • stripTrailingZeros

      public BigDecimal stripTrailingZeros()
      返回一个BigDecimal，其数值与此BigDecimal相等，但从表示中删除任何尾随零。例如，从BigDecimal值600.0中删除尾随零，其[BigInteger，scale]组件等于[6000, 1]，将得到6E2，其[BigInteger，scale]组件等于[6, -2]。如果此BigDecimal数值等于零，则返回BigDecimal.ZERO。
      返回：
      一个数值等于BigDecimal的，删除了任何尾随零的BigDecimal。
      抛出：
      ArithmeticException - 如果标度溢出。
      自：
      1.5

    • compareTo

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

    • equals

      public boolean equals(Object x)
      与指定的Object比较此BigDecimal是否相等。与compareTo不同，此方法仅在值和比例相等时才认为两个BigDecimal对象相等。因此，通过此方法比较时，2.0不等于2.00，因为前者的[BigInteger，scale]组件等于[20, 1]，而后者的组件等于[200, 2]。
      覆盖:
      equals 在类 Object
      API注释:
      一个示例表明2.0和2.00在某些算术操作下不能互换。这两个表达式是：
      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 - 要与此BigDecimal进行比较的Object。
      返回值:
      如果指定的Object是其值和比例与此BigDecimal相等，则返回true。
      参见:

    • min

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

    • max

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

    • hashCode

      public int hashCode()
      返回此BigDecimal的哈希码。哈希码是根据此BigDecimal的无标度值和比例计算的。
      覆盖:
      hashCode 在类 Object
      API注释:
      数值相等但比例不同的两个BigDecimal对象（如2.0和2.00）通常不具有相同的哈希码。
      返回值:
      此BigDecimal的哈希码。
      参见:

    • toString

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

      按照以下步骤创建BigDecimal的标准规范字符串形式：首先，将BigDecimal的无标度值的绝对值使用字符'0'到'9'转换为十进制字符串，不带前导零（除非其值为零，在这种情况下使用单个'0'字符）。

      接下来，计算一个调整指数；这是负的比例，加上转换后的无标度值中的字符数，减去一。即，-scale+(ulength-1)，其中ulength是十进制数字中无标度值的绝对值的长度（其精度）。

      如果比例大于或等于零且调整指数大于或等于-6，则将转换为字符形式的数字，而不使用指数表示法。在这种情况下，如果比例为零，则不添加小数点，如果比例为正，则插入一个小数点，比例指定小数点右侧的字符数。根据需要在转换后的无标度值左侧添加'0'字符。如果在此插入小数点后没有字符，则在小数点之前添加传统的'0'字符。

      否则（即，如果比例为负数，或调整指数小于-6），将使用指数表示法将数字转换为字符形式。在这种情况下，如果转换后的BigInteger有多于一个数字，则在第一个数字后插入小数点。然后，在转换后的无标度值（可能带有插入的小数点）后缀指数的字符形式；这由字母'E'后面紧跟调整指数转换为字符形式组成。后者是十进制，使用字符'0'到'9'，没有前导零，并且始终由符号字符'-'（'\u002D'）前缀（如果调整指数为负数，则为负号，否则为正号'+'（'\u002B'））。

      最后，如果无标度值小于零，则整个字符串前缀为减号字符'-'（'\u002D'）。如果无标度值为零或正数，则不添加符号字符。

      示例：

      对于左侧的每个表示[无标度值, 比例]，显示右侧的结果字符串。

       [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值与此转换的结果之间存在一对一的映射。也就是说，每个可区分的BigDecimal值（无标度值和比例）在使用toString时具有唯一的字符串表示形式。如果将该字符串表示形式使用BigDecimal(String)构造函数转换回BigDecimal，则将恢复原始值。
      2. 给定数字的生成字符串始终相同；它不受区域设置的影响。这意味着它可以用作交换十进制数据的规范字符串表示，或作为Hashtable的键等。区域设置敏感的数字格式化和解析由NumberFormat类及其子类处理。
      3. 可以使用toEngineeringString()方法以工程符号表示法呈现带有指数的数字，可以使用setScale方法对BigDecimal进行四舍五入，使其具有已知小数点后的数字。
      4. 使用Character.forDigit提供的数字到字符映射。
      覆盖:
      toString 在类 Object
      返回值:
      此BigDecimal的字符串表示形式。
      参见:

    • toEngineeringString

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

      返回一个字符串，表示BigDecimal如toString()方法中描述的，只是如果使用指数表示法，则调整十的幂为三的倍数（工程符号表示法），使得非零值的整数部分在1到999的范围内。如果对零值使用指数表示法，则使用小数点和一个或两个小数零位，以保留零值的比例。请注意，与toString()的输出不同，如果将输出字符串转换回BigDecimal，则不保证此方法的输出将恢复此BigDecimal的相同[整数，比例]对。此方法的结果满足更弱的约束，即始终从将字符串构造函数应用于方法输出中产生数值相等的结果。

      返回值:
      返回此 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 在数值上等于具有 this 标度的 1。结果与 this 具有相同的标度存储，因此零值和非零值的结果均等于 [1, this.scale()]。
      返回值:
      this 的 ulp 的大小
      自版本:
      1.5