相关文章推荐
小百科  ›  BigDecimal_Java API中文文档 - itmyhome(http://itmyhome.com)
字符数组 bigdecimal比较大小 bigdecimal 构造方法
知识渊博的奔马
8 月前
不可变的、任意精度的有符号十进制数。 BigDecimal 由任意精度的整数 非标度值 和 32 位的整数 标度 (scale) 组成。如果为零或正数，则标度是小数点后的位数。如果为负数，则将该数的非标度值乘以 10 的负 scale 次幂。因此， BigDecimal 表示的数值是 (unscaledValue × 10 -scale ) 。

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

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

当为 MathContext 对象提供 0 的精度设置（例如， MathContext.UNLIMITED ）时，算术运算是准确的，它们是不采用任何 MathContext 对象的算术方法。（这是第 5 版之前的版本支持的唯一行为。）为了计算准确结果，不使用附带 0 精度设置的 MathContext 对象的舍入模式设置，因此与该对象无关。在除法中，准确的商可能是一个无限长的十进制扩展；例如，1 除以 3 所得的商。如果商具有无穷的十进制扩展，但是指定了该操作返回准确结果，则抛出 ArithmeticException 。否则，像其他操作那样，返回除法运算的准确结果。

当精度设置不为 0 时， BigDecimal 算法的规则完全符合 ANSI X3.274-1996 和 ANSI X3.274-1996/AM 1-2000（ 7.4 节）中定义的算法的可选操作模式。与上述标准不同， BigDecimal 包括多种舍入模式，它们对于版本 5 以前的 BigDecimal 版本中的除法是强制性的。这些 ANSI 标准和 BigDecimal 规范之间的任何冲突都按照有利于 BigDecimal 的方式进行解决。

由于同一数值可以有不同的表示形式（具有不同的标度），因此运算和舍入的规则必须同时指定数值结果和结果表示形式中所用的标度。

一般情况下，当准确结果（在除法中，可能有无限多位）比返回的数值具有更多位数时，舍入模式和精度设置确定操作如何返回具有有限位数的结果。 首先， MathContext 的 precision 设置指定要返回的总位数；这确定了结果的 精度 。位数计数从准确结果的最左边的非零数字开始。舍入模式确定丢弃的尾部位数如何影响返回的结果。

对于所有算术运算符，运算的执行方式是，首先计算准确的中间结果，然后，使用选择的舍入模式将其舍入为精度设置（如有必要）指定的位数。如果不返回准确结果，则将丢弃准确结果的某些数位。当舍入增加了返回结果的大小时，前导数字“9”的进位传播可能会创建新的数位。例如，将值 999.9 舍入为三位数字，则在数值上等于一千，表示为 100×10 1 。在这种情况下，新的 "1" 是返回结果的前导数位。

除了逻辑的准确结果外，每种算术运算都有一个表示结果的首选标度。下表列出了每个运算的首选标度。

算术运算结果的首选标度 运算结果的首选标度 加max(addend.scale(), augend.scale()) 减max(minuend.scale(), subtrahend.scale()) 乘multiplier.scale() + multiplicand.scale() 除dividend.scale() - divisor.scale() 这些标度是返回准确算术结果的方法使用的标度；准确相除可能必须使用较大的标度除外，因为准确的结果可能有较多的位数。例如， 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 ，创建的方法是按指定方向将小数点移动一个指定距离。

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

注：如果 BigDecimal 对象用作 SortedMap 中的键或 SortedSet 中的元素，则应特别小心，因为 BigDecimal 的 自然排序 与 equals 方法不一致 。有关更多信息，请参见 Comparable 、 SortedMap 或 SortedSet 。

当为任何输入参数传递 null 对象引用时，此类的所有方法和构造方法都将抛出 NullPointerException 。           将 BigDecimal 的字符数组表示形式转换为 BigDecimal ，接受与 BigDecimal(String) 构造方法相同的字符序列，同时允许指定子数组，并根据上下文设置进行舍入。 BigDecimal (char[] in, MathContext mc) 将 BigDecimal 的字符数组表示形式转换为 BigDecimal ，接受与 BigDecimal(String) 构造方法相同的字符序列（根据上下文设置进行舍入）。 BigDecimal (double val) 将 double 转换为 BigDecimal ，后者是 double 的二进制浮点值准确的十进制表示形式。 BigDecimal (double val, MathContext mc) 将 double 转换为 BigDecimal （根据上下文设置进行舍入）。 BigDecimal (int val) 将 int 转换为 BigDecimal 。 BigDecimal (int val, MathContext mc) 将 int 转换为 BigDecimal （根据上下文设置进行舍入）。 BigDecimal (long val) 将 long 转换为 BigDecimal 。 BigDecimal (long val, MathContext mc) 将 long 转换为 BigDecimal （根据上下文设置进行舍入）。 BigDecimal ( String val) 将 BigDecimal 的字符串表示形式转换为 BigDecimal 。 BigDecimal ( String val, MathContext mc) 将 BigDecimal 的字符串表示形式转换为 BigDecimal ，接受与 BigDecimal(String) 构造方法相同的字符串（按照上下文设置进行舍入）。 public static final int ROUND_CEILING

接近正无穷大的舍入模式。如果 BigDecimal 为正，则舍入行为与 ROUND_UP 相同；如果为负，则舍入行为与 ROUND_DOWN 相同。注意，此舍入模式始终不会减少计算值。
另请参见：
常量字段值
public static final int ROUND_FLOOR
接近负无穷大的舍入模式。如果 BigDecimal 为正，则舍入行为与 ROUND_DOWN 相同；如果为负，则舍入行为与 ROUND_UP 相同。注意，此舍入模式始终不会增加计算值。
另请参见：
常量字段值
public static final int ROUND_HALF_UP
向“最接近的”数字舍入，如果与两个相邻数字的距离相等，则为向上舍入的舍入模式。如果舍弃部分 >= 0.5，则舍入行为与 ROUND_UP 相同；否则舍入行为与 ROUND_DOWN 相同。注意，这是我们大多数人在小学时就学过的舍入模式。
另请参见：
常量字段值
public static final int ROUND_HALF_DOWN
向“最接近的”数字舍入，如果与两个相邻数字的距离相等，则为上舍入的舍入模式。如果舍弃部分 > 0.5，则舍入行为与 ROUND_UP 相同；否则舍入行为与 ROUND_DOWN 相同。
另请参见：
常量字段值
public static final int ROUND_HALF_EVEN
向“最接近的”数字舍入，如果与两个相邻数字的距离相等，则向相邻的偶数舍入。如果舍弃部分左边的数字为奇数，则舍入行为与 ROUND_HALF_UP 相同；如果为偶数，则舍入行为与 ROUND_HALF_DOWN 相同。注意，在重复进行一系列计算时，此舍入模式可以将累加错误减到最小。
另请参见：
常量字段值
public static final int ROUND_UNNECESSARY
断言请求的操作具有精确的结果，因此不需要舍入。如果对获得精确结果的操作指定此舍入模式，则抛出 ArithmeticException 。
另请参见：
常量字段值
int len)
将 BigDecimal 的字符数组表示形式转换为 BigDecimal ，接受与 BigDecimal(String) 构造方法相同的字符序列，同时允许指定子数组。

注意，如果字符数组中已经提供字符的序列，则使用此构造方法要比将 char 数组转换为字符串并使用 BigDecimal(String) 构造方法更快。

参数：
in - 作为源字符的 char 数组。
offset - 要检查的数组中的第一个字符。
len - 要考虑的字符数。
NumberFormatException - 如果 in 不是 BigDecimal 的有效表示形式，或者定义的子数组不完全在 in 中。
从以下版本开始：
MathContext mc)
将 BigDecimal 的字符数组表示形式转换为 BigDecimal ，接受与 BigDecimal(String) 构造方法相同的字符序列，同时允许指定子数组，并根据上下文设置进行舍入。

注意，如果字符数组中已经提供字符的序列，则使用此构造方法要比将 char 数组转换为字符串并使用 BigDecimal(String) 构造方法更快。

参数：
in - 作为源字符的 char 数组。
offset - 要检查的数组中的第一个字符。
len - 要考虑的字符数。
mc - 要使用的上下文。
ArithmeticException - 如果结果不准确，且舍入模式为 UNNECESSARY 。
NumberFormatException - 如果 in 不是 BigDecimal 的有效表示形式，或者定义的子数组不完全在 in 中。
从以下版本开始：
public BigDecimal (char[] in)
将 BigDecimal 的字符数组表示形式转换为 BigDecimal ，接受与 BigDecimal(String) 构造方法相同的字符序列。

注意，如果字符序列已经可以作为一个字符数组使用，则使用此构造方法要比将 char 数组转换为字符串并使用 BigDecimal(String) 构造方法更快。

参数：
in - 作为源字符的 char 数组。
NumberFormatException - 如果 in 不是 BigDecimal 的有效表示形式。
从以下版本开始：
MathContext mc)
将 BigDecimal 的字符数组表示形式转换为 BigDecimal ，接受与 BigDecimal(String) 构造方法相同的字符序列（根据上下文设置进行舍入）。

注意，如果字符序列已经可以作为一个字符数组使用，则使用此构造方法要比将 char 数组转换为字符串并使用 BigDecimal(String) 构造方法更快。

参数：
in - 作为源字符的 char 数组。
mc - 要使用的上下文。
ArithmeticException - 如果结果不准确，且舍入模式为 UNNECESSARY 。
NumberFormatException - 如果 in 不是 BigDecimal 的有效表示形式。
从以下版本开始：
public BigDecimal ( String val)
将 BigDecimal 的字符串表示形式转换为 BigDecimal 。字符串表示形式由可选符号 '+' ( '\u002B' ) 或 '-' ( '\u002D' ) 组成，后跟零或多个十进制数字（“整数”）的序列，可以选择后跟一个小数，也可以选择后跟一个指数。

该小数由小数点以及后跟的零或更多十进制数字组成。字符串必须至少包含整数或小数部分中的一个数字。由符号、整数和小数部分组成的数字称为 有效位数 。

指数由字符 'e' （ '\u0065' ) 或 'E' ( '\u0045' ) 以及后跟的一个或多个十进制数字组成。指数的值必须位于 Integer.MAX_VALUE ( Integer.MIN_VALUE +1) 和 Integer.MAX_VALUE （包括）之间。

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

BigDecimalString:
Sign opt Significand Exponent opt

Sign:

Significand:
IntegerPart . FractionPart opt
. FractionPart
IntegerPart

IntegerPart:
Digits

FractionPart:
Digits

Exponent:
ExponentIndicator SignedInteger

ExponentIndicator:

SignedInteger:
Sign opt Digits

Digits:
Digit
Digits Digit

Digit:
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]

注：对于不是 float 、 double NaN 和 ±Infinity 的值，此构造方法与 Float.toString(float) 和 Double.toString(double) 返回的值兼容。这通常是将 float 或 double 转换为 BigDecimal 的首选方法，因为它不会遇到 BigDecimal(double) 构造方法的不可预知问题。

参数：
val - BigDecimal 的字符串表示形式。
NumberFormatException - 如果 val 不是 BigDecimal 的有效表示形式。
MathContext mc)
将 BigDecimal 的字符串表示形式转换为 BigDecimal ，接受与 BigDecimal(String) 构造方法相同的字符串（按照上下文设置进行舍入）。
参数：
val - BigDecimal 的字符串表示形式。
mc - 要使用的上下文。
ArithmeticException - 如果结果不准确，且舍入模式为 UNNECESSARY 。
NumberFormatException - 如果 val 不是 BigDecimal 的有效表示形式。
从以下版本开始：
public BigDecimal (double val)
将 double 转换为 BigDecimal ，后者是 double 的二进制浮点值准确的十进制表示形式。返回的 BigDecimal 的标度是使 (10 scale × val) 为整数的最小值。 此构造方法的结果有一定的不可预知性。有人可能认为在 Java 中写入 new BigDecimal(0.1) 所创建的 BigDecimal 正好等于 0.1（非标度值 1，其标度为 1），但是它实际上等于 0.1000000000000000055511151231257827021181583404541015625。这是因为 0.1 无法准确地表示为 double （或者说对于该情况，不能表示为任何有限长度的二进制小数）。这样， 传入 到构造方法的值不会正好等于 0.1（虽然表面上等于该值）。 另一方面， String 构造方法是完全可预知的：写入 new BigDecimal("0.1") 将创建一个 BigDecimal ，它 正好 等于预期的 0.1。因此，比较而言，通常建议优先使用 String 构造方法 。 当 double 必须用作 BigDecimal 的源时，请注意，此构造方法提供了一个准确转换；它不提供与以下操作相同的结果：先使用 Double.toString(double) 方法，然后使用 BigDecimal(String) 构造方法，将 double 转换为 String 。要获取该结果，请使用 static valueOf(double) 方法。
参数：
val - 要转换为 BigDecimal 的 double 值。
NumberFormatException - 如果 val 为无穷大或 NaN。
MathContext mc)
将 double 转换为 BigDecimal （根据上下文设置进行舍入）。 BigDecimal 的标度是使 (10 scale × val) 为整数的最小值。

此构造方法的结果有一定的不可预知性，通常不建议使用它，请参见 BigDecimal(double) 构造方法下面的注释。

参数：
val - 要转换为 BigDecimal 的 double 值。
mc - 要使用的上下文。
ArithmeticException - 如果结果不准确，但是 RoundingMode 为 UNNECESSARY。
NumberFormatException - 如果 val 为无穷大或 NaN。
从以下版本开始：
参数：
val - 要转换为 BigDecimal 的 BigInteger 值。
mc - 要使用的上下文。
ArithmeticException - 如果结果不准确，但是舍入模式为 UNNECESSARY 。
从以下版本开始：
int scale)
将 BigInteger 非标度值和 int 标度转换为 BigDecimal 。 BigDecimal 的值为 (unscaledVal × 10 -scale ) 。
参数：
unscaledVal - BigDecimal 的非标度值。
scale - BigDecimal 的标度。
MathContext mc)
将 BigInteger 非标度值和 int 标度转换为 BigDecimal （根据上下文设置进行舍入）。 BigDecimal 的值为 (unscaledVal × 10 -scale ) ，它是根据 precision 和舍入模式设置进行舍入的。
参数：
unscaledVal - BigDecimal 的非标度值。
scale - BigDecimal 的标度。
mc - 要使用的上下文。
ArithmeticException - 如果结果不准确，但是舍入模式为 UNNECESSARY 。
从以下版本开始：
参数：
val - 要转换为 BigDecimal 的 int 值。
mc - 要使用的上下文。
ArithmeticException - 如果结果不准确，但是舍入模式为 UNNECESSARY 。
从以下版本开始：
参数：
val - 要转换为 BigDecimal 的 long 值。
mc - 要使用的上下文。
ArithmeticException - 如果结果不准确，但是舍入模式为 UNNECESSARY 。
从以下版本开始：
public static BigDecimal valueOf (double val)
使用 Double.toString(double) 方法提供的 double 规范的字符串表示形式将 double 转换为 BigDecimal 。

注： 这通常是将 double （或 float ）转化为 BigDecimal 的首选方法，因为返回的值等于从构造 BigDecimal （使用 Double.toString(double) 得到的结果）得到的值。

返回：
this + augend ，必要时进行舍入。
ArithmeticException - 如果结果不准确，但是舍入模式为 UNNECESSARY 。
从以下版本开始：
返回：
this - subtrahend ，必要时进行舍入。
ArithmeticException - 如果结果不准确，但是舍入模式为 UNNECESSARY 。
从以下版本开始：
返回：
必要时舍入的 this * multiplicand 。
ArithmeticException - 如果结果不准确，但是舍入模式为 UNNECESSARY 。
从以下版本开始：
int roundingMode)
返回一个 BigDecimal ，其值为 (this / divisor) ，其标度为指定标度。如果必须执行舍入，以生成具有指定标度的结果，则应用指定的舍入模式。

相对于此遗留方法，应优先使用新的 divide(BigDecimal, int, RoundingMode) 方法。

参数：
divisor - 此 BigDecimal 要除以的值。
scale - 要返回的 BigDecimal 商的标度。
roundingMode - 要应用的舍入模式。
返回：
this / divisor
ArithmeticException - 如果 divisor 为零，则 roundingMode==ROUND_UNNECESSARY 和指定的标度不足以准确地表示相除的结果。
IllegalArgumentException - 如果 roundingMode 不表示一个有效的舍入模式。
另请参见：
ROUND_UP , ROUND_DOWN , ROUND_CEILING , ROUND_FLOOR , ROUND_HALF_UP , ROUND_HALF_DOWN , ROUND_HALF_EVEN , ROUND_UNNECESSARY
参数：
divisor - 此 BigDecimal 要除以的值。
scale - 要返回的 BigDecimal 商的标度。
roundingMode - 要应用的舍入模式。
返回：
this / divisor
ArithmeticException - 如果 divisor 为零，则 roundingMode==RoundingMode.UNNECESSARY 和指定的标度不足以准确地表示相除的结果。
从以下版本开始：
int roundingMode)
返回一个 BigDecimal ，其值为 (this / divisor) ，其标度为 this.scale() 。如果必须执行舍入，以生成具有给定标度的结果，则应用指定的舍入模式。

相对于此遗留方法，应优先使用新的 divide(BigDecimal, RoundingMode) 方法。

返回：
this / divisor
ArithmeticException - 如果 divisor==0 或者 roundingMode==ROUND_UNNECESSARY 和 this.scale() 不足以准确地表示相除的结果。
IllegalArgumentException - 如果 roundingMode 不表示一个有效的舍入模式。
另请参见：
ROUND_UP , ROUND_DOWN , ROUND_CEILING , ROUND_FLOOR , ROUND_HALF_UP , ROUND_HALF_DOWN , ROUND_HALF_EVEN , ROUND_UNNECESSARY
返回：
this / divisor
ArithmeticException - 如果 divisor==0 或者 roundingMode==RoundingMode.UNNECESSARY 和 this.scale() 不足以准确地表示相除的结果。
从以下版本开始：
返回：
this / divisor ，必要时进行舍入。
ArithmeticException - 如果结果不准确，但是舍入模式为 UNNECESSARY 或 mc.precision == 0 ，并且商值具有无穷的十进制扩展。
从以下版本开始：
ArithmeticException - 如果 divisor==0
ArithmeticException - 如果 mc.precision > 0，并且该结果需要的精度大于 mc.precision 。
从以下版本开始：
MathContext mc)
返回其值为 (this % divisor) 的 BigDecimal （根据上下文设置进行舍入）。 MathContext 设置会影响用于计算余数的隐式除法。余数计算本身要进行准确的定义。因此，余数包含的数字个数可能多于 mc.getPrecision() 。

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

ArithmeticException - 如果 divisor==0
ArithmeticException - 如果结果不准确，但舍入模式为 UNNECESSARY ，或者 mc.precision > 0，并且 this.divideToIntgralValue(divisor) 的结果要求的精度大于 mc.precision 。
从以下版本开始：
另请参见：
divideToIntegralValue(java.math.BigDecimal, java.math.MathContext)
public BigDecimal [] divideAndRemainder ( BigDecimal divisor)
返回由两个元素组成的 BigDecimal 数组，该数组包含 divideToIntegralValue 的结果，后跟对两个操作数计算所得到的 remainder 。

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

参数：
divisor - 此 BigDecimal 要相除的值和计算的余数。
返回：
由两个元素组成的 BigDecimal 数组：商值（ divideToIntegralValue 的结果）是初始元素，余数是最终元素。
ArithmeticException - 如果 divisor==0
从以下版本开始：
另请参见：
divideToIntegralValue(java.math.BigDecimal, java.math.MathContext) , remainder(java.math.BigDecimal, java.math.MathContext)
MathContext mc)
返回由两个元素组成的 BigDecimal 数组，该数组包含 divideToIntegralValue 的结果，后跟根据上下文设置对两个操作数进行舍入计算所得到的 remainder 的结果。

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

参数：
divisor - 此 BigDecimal 要相除的值和计算的余数。
mc - 要使用的上下文。
返回：
由两个元素组成的 BigDecimal 数组：商值（ divideToIntegralValue 的结果）是初始元素，余数是最终元素。
ArithmeticException - 如果 divisor==0
ArithmeticException - 如果结果不准确，但舍入模式为 UNNECESSARY ，或者 mc.precision > 0，并且 this.divideToIntgralValue(divisor) 的结果要求的精度大于 mc.precision 。
从以下版本开始：
另请参见：
divideToIntegralValue(java.math.BigDecimal, java.math.MathContext) , remainder(java.math.BigDecimal, java.math.MathContext)
返回其值为 (this n ) 的 BigDecimal ，准确计算该幂，使其具有无限精度。

参数 n 必须在 0 到 999999999（包括）之间。 ZERO.pow(0) 返回 ONE 。 注意，未来版本可能会扩展此方法允许的指数范围。 MathContext mc)

返回其值为 (this n ) 的 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 为零，则返回 ONE （即使 this 为零），否则
  • 如果 n 为正数，则通过重复的平方技术将此结果计算到一个累加器中。每个附带累加器的乘法都使用与 mc 中相同的数学上下文设置，增加到 mc.precision + elength + 1 的精度除外，其中 elength 表示 n 中的十进制数字的个数。
  • 如果 n 为负数，则将 n 视为正数计算其结果；然后使用上面指定的工作精度，用一除以此值。
  • 然后将正数或负数的最终值舍入为目标精度。
    • 返回：
    使用 ANSI 标准 X3.274-1996 算法的 this n
    ArithmeticException - 如果该结果不准确，但是舍入模式为 UNNECESSARY ，或者 n 超出范围。
    从以下版本开始：
    返回：
    this ，必要时进行舍入。零结果具有的标度为 0。
    ArithmeticException - 如果结果不准确，但是舍入模式为 UNNECESSARY 。
    从以下版本开始：
    另请参见：
    round(MathContext)
    public BigDecimal round ( MathContext mc)
    返回根据 MathContext 设置进行舍入后的 BigDecimal 。如果精度设置为 0，则不进行任何舍入操作。

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

    返回：
    根据 MathContext 设置舍入后的 BigDecimal 。
    ArithmeticException - 如果舍入模式为 UNNECESSARY ，并且 BigDecimal 操作要求进行舍入。
    从以下版本开始：
    另请参见：
    plus(MathContext)
    参数：
    newScale - 要返回的 BigDecimal 值的标度。
    roundingMode - 要应用的舍入模式。
    返回：
    一个 BigDecimal ，其标度为指定值，其非标度值可以通过此 BigDecimal 的非标度值乘以或除以十的适当次幂来确定，以维护其总值。
    ArithmeticException - 如果 roundingMode==UNNECESSARY ，并且指定的标度操作要求进行舍入。
    从以下版本开始：
    另请参见：
    RoundingMode
    int roundingMode)
    返回一个 BigDecimal ，其标度为指定值，其非标度值通过此 BigDecimal 的非标度值乘以或除以十的适当次幂来确定，以维护其总值。如果该操作减少标度，则非标度值必须被除（而不是乘），并且该值可以更改；在这种情况下，将指定的舍入模式应用到除法中。

    注意，由于 BigDecimal 对象是不可变的，此方法的调用 不会 导致初始对象被修改，这与使用名为 set X 变异字段 X 方法的常规约定相反。相反， setScale 返回具有适当标度的对象；返回的对象不一定是新分配的。

    相对于此遗留方法，应优先使用新的 setScale(int, RoundingMode) 方法。

    参数：
    newScale - 要返回的 BigDecimal 值的标度。
    roundingMode - 要应用的舍入模式。
    返回：
    一个 BigDecimal ，其标度为指定值，其非标度值可以通过此 BigDecimal 的非标度值乘以或除以十的适当次幂来确定。
    ArithmeticException - 如果 roundingMode==ROUND_UNNECESSARY ，并且指定的标度操作要求进行舍入。
    IllegalArgumentException - 如果 roundingMode 不表示一个有效的舍入模式。
    另请参见：
    ROUND_UP , ROUND_DOWN , ROUND_CEILING , ROUND_FLOOR , ROUND_HALF_UP , ROUND_HALF_DOWN , ROUND_HALF_EVEN , ROUND_UNNECESSARY
    public BigDecimal setScale (int newScale)
    返回一个 BigDecimal ，其标度为指定值，其值在数值上等于此 BigDecimal 的值。如果这不可能，则抛出 ArithmeticException 。

    此调用通常用于增加标度，在这种情况下，可以保证存在指定标度和正确值的 BigDecimal 。如果调用方知道 BigDecimal 在其小数部分的结尾有足够多的零（即其整数值中的十的因子），则该调用也可用于减少标度，以允许重新标度，而不更改其值。

    此方法返回与 setScale 的两个参数版本相同的结果，但是，为调用方省去了指定舍入模式的麻烦（舍入模式不影响结果）。

    注意，由于 BigDecimal 对象是不可变的，因此此方法的调用 不会 导致初始对象被修改，这与使用名为 set X 变异字段 X 方法的常规约定相反。相反， setScale 返回具有适当标度的对象；返回的对象不一定是新分配的。

    参数：
    newScale - 要返回的 BigDecimal 值的标度。
    返回：
    一个 BigDecimal ，其标度为指定值，其非标度值可以通过此 BigDecimal 的非标度值乘以或除以十的适当次幂来确定，以维护其总值。
    ArithmeticException - 如果指定的标度操作要求进行舍入。
    另请参见：
    setScale(int, int) , setScale(int, RoundingMode)
    public int compareTo ( BigDecimal val)
    将此 BigDecimal 与指定的 BigDecimal 比较。根据此方法，值相等但具有不同标度的两个 BigDecimal 对象（如，2.0 和 2.00）被认为是相等的。相对六个 boolean 比较运算符 (<, ==, >, >=, !=, <=) 中每一个运算符的各个方法，优先提供此方法。建议使用以下语句执行上述比较： (x.compareTo(y) < op > 0) ，其中 < op > 是六个比较运算符之一。
    指定者：
    接口 Comparable < BigDecimal > 中的 compareTo
    参数：
    val - 将此 BigDecimal 与之比较的 BigDecimal 。
    返回：
    当此 BigDecimal 在数字上小于、等于或大于 val 时，返回 -1、0 或 1。
    public boolean equals ( Object x)
    比较此 BigDecimal 与指定的 Object 的相等性。与 compareTo 不同，仅当两个 BigDecimal 对象的值和标度都相等时，此方法才认为它们相等（因此通过此方法进行比较时，2.0 不等于 2.00）。
    覆盖：
    类 Object 中的 equals
    参数：
    x - 将与此 BigDecimal 进行比较的 Object 。
    返回：
    当且仅当指定的 Object 为 BigDecimal ，并且其值和标度都等于此 BigDecimal 的值和标度时，返回 true 。
    另请参见：
    compareTo(java.math.BigDecimal) , hashCode()
    public int hashCode ()
    返回此 BigDecimal 的哈希码。注意，数值上相等但标度不同的两个 BigDecimal 对象（如，2.0 和 2.00）通常 没有 相同的哈希码。
    覆盖：
    类 Object 中的 hashCode
    返回：
    此 BigDecimal 的哈希码。
    另请参见：
    equals(Object)
    返回此 BigDecimal 的字符串表示形式，如果需要指数，则使用科学记数法。

    根据以下步骤可创建 BigDecimal 的标准的规范化字符串形式：首先，使用不带前导零的字符 '0' 至 '9' （如果其值为零，则使用单个 '0' 字符）将 BigDecimal 的非标度值的绝对值转换为以十为基数的字符串。

    其次，计算 调整的指数 ；这是无效的标度，加上转换的非标度值中的字符数减 1。即： -scale+(ulength-1) ，其中 ulength 是十进制数字中非标度值的绝对值的长度（其 精度 ）。

    如果该标度大于或等于零，并且调整的指数大于或等于 -6 ，则在不使用指数记数法的情况下将该数转换为字符形式。在这种情况下，如果标度为零，则不添加小数点，如果标度为正数，则插入小数点，且标度指定了小数点右边的字符个数。必要时，将字符 '0' 添加到转换的非标度值的左边。如果插入后小数点前面没有字符，则以传统字符 '0' 为前缀。

    否则（即：如果标度为负数，或者调整的指数小于 -6 ），使用指数记数法将该数转换为字符形式。在这种情况下，如果转换后的 BigInteger 多于一位数，则小数点插入在第一个数字之后。然后，将字符形式的指数作为转换的非标度值（也许具有插入的小数点）的后缀；这包含字母 'E' 和直接跟在其后的转换为字符形式的调整指数。后者的基数为十，使用的字符是 '0' 到 '9' ，没有前导零，并且，如果调整的指数为负数，则总是以符号字符 '-' ( '\u002D' ) 为前缀，否则以 '+' ( '\u002B' ) 为前缀。

    最后，如果非标度值小于零，则整个字符串以减号 '-' ( '\u002D' ) 为前缀。如果非标度值为零或正数，则不使用符号字符作为前缀。

    对于左边的每个表示形式 [ unscaled value , 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"

  • 可区分的 BigDecimal 值和此转换的结果之间存在一对一的映射关系。即：每个可区分的 BigDecimal 值（非标度值和标度）都有唯一的字符串表示形式，作为使用 toString 的结果。如果使用 BigDecimal(String) 构造方法将该字符串表示形式转换为 BigDecimal ，则将恢复初始值。
  • 给定的数产生的字符串总是相同的；它不受语言环境的影响。这意味着它可以用作交换十进制数据的规范化字符串表示形式，或用作 Hashtable 的关键字等等。 NumberFormat 类及其子类可以处理区分语言环境的数的格式化和分析。
  • toEngineeringString() 方法可用于在工程计数法中表示带有指数的数。 setScale 方法可用于对 BigDecimal 进行舍入，使其小数点后的位数为已知位数。
  • 使用 Character.forDigit 提供的数字到字符的映射关系。
    返回此 BigDecimal 的字符串表示形式，需要指数时，则使用工程计数法。

    返回如 toString() 方法中所描述的表示 BigDecimal 的字符串，不包括使用指数记数法的情况，将十的幂调整为三的倍数（工程记数法），这样，非零值的整数部分的范围是 1 到 999。如果对零值使用指数记数法，则使用小数点和小数的一（或二）个零数字，以便保留零值的标度。注意，与 toString() 的输出不同，如果使用 string constructor 将输出字符串转换为 BigDecimal ，则此方法的输出 不 保证恢复此 BigDecimal 的相同 [integer, scale] 对。此方法满足以下较弱约束，即产生的结果在数值上始终等于将字符串构造方法应用到方法的输出得到的结果。 public String toPlainString ()

    返回不带指数字段的此 BigDecimal 的字符串表示形式。对于具有正标度的值，小数点右边的数字个数用于指示标度。对于具有零或负标度的值，生成得到的字符串，好像将该值转换为在数值上等于具有零标度的值一样，并且好像零标度值的所有尾部零都出现在该结果中。 如果非标度值小于零，则整个字符串以减号 '-' ( '\u002D' ) 为前缀。如果非标度值为零或正数，则没有任何符号字符作为前缀。 注意，如果将此方法的结果传递到 string constructor ，则只需要恢复此 BigDecimal 的数值；新的 BigDecimal 的表示形式可以有不同的标度。尤其是，如果此 BigDecimal 具有负标度，则在由字符串构造方法进行处理时，此方法产生的字符串将具有零标度。 （此方法的作用类似于 1.4 和更早版本中的 toString 方法。） public BigInteger toBigInteger ()
    将此 BigDecimal 转换为 BigInteger 。此转换类似于 Java Language Specification 中定义的从 double 到 long 的 基本收缩转换 ：将丢弃此 BigDecimal 的小数部分。注意，此转换会丢失关于 BigDecimal 值的精度信息。 要在转换不准确时（即当丢弃非零小数部分时）抛出异常，请使用 toBigIntegerExact() 方法。 public long longValue ()
    将此 BigDecimal 转换为 long 。此转换类似于 Java Language Specification 中定义的从 double 到 short 的 基本收缩转换 ：将丢弃此 BigDecimal 的小数部分，并且如果生成的 " BigInteger " 太大而不适合用 long 表示，则仅返回 64 位低位字节。注意，此转换会丢失关于此 BigDecimal 值的总大小和精度的信息，并返回带有相反符号的结果。
    指定者：
    类 Number 中的 longValue
    返回：
    转换为 long 的此 BigDecimal 。
    返回：
    转换为 long 的此 BigDecimal 。
    ArithmeticException - 如果 this 具有非零小数部分，或者不适合用 long 表示。
    从以下版本开始：
    public int intValue ()
    将此 BigDecimal 转换为 int 。此转换类似于 Java Language Specification 中定义的从 double 到 short 的 基本收缩转换 ：将丢弃此 BigDecimal 的所有小数部分，并且如果生成的 " BigInteger " 太大而不适合用 int 表示，则仅返回 32 位低位字节。注意，此转换会丢失关于此 BigDecimal 值的总大小和精度的信息，并返回带有相反符号的结果。
    指定者：
    类 Number 中的 intValue
    返回：
    转换为 int 的此 BigDecimal 。
    返回：
    转换为 int 的此 BigDecimal 。
    ArithmeticException - 如果 this 具有非零小数部分，或者不适合用 int 表示。
    从以下版本开始：
    返回：
    转换为 short 的此 BigDecimal 。
    ArithmeticException - 如果 this 具有非零小数部分，或者不适合用 short 表示。
    从以下版本开始：
    返回：
    转换为 byte 的此 BigDecimal 。
    ArithmeticException - 如果 this 具有非零小数部分，或者不适合用 byte 表示。
    从以下版本开始：
    public float floatValue ()
    将此 BigDecimal 转换为 float 。此转换类似于 Java Language Specification 中定义的从 double 到 float 的 基本收缩转换 ：如此 BigDecimal 的值太大而不能表示为 float ，则将其适当地转换为 Float.NEGATIVE_INFINITY 或 Float.POSITIVE_INFINITY 。注意，即使在返回值为有限值的情况下，此转换也可能丢失关于 BigDecimal 值精度的信息。
    指定者：
    类 Number 中的 floatValue
    返回：
    转换为 float 的此 BigDecimal 。
    public double doubleValue ()
    将此 BigDecimal 转换为 double 。此转换类似于 Java Language Specification 中定义的从 double 到 float 的 基本收缩转换 ：如果此 BigDecimal 的数量太大而不能表示为 double ，则将其适当地转换为 Double.NEGATIVE_INFINITY 或 Double.POSITIVE_INFINITY 。注意，即使在返回值为有限值的情况下，此转换也可能丢失关于 BigDecimal 值精度的信息。
    指定者：
    类 Number 中的 doubleValue
    返回：
    转换为 double 的此 BigDecimal 。

    •  
    推荐文章
    Link管理   ·   51好读   ·   Sov5搜索   ·   小百科
    小百科 - 百科知识指南