BigDecimal (Java Platform SE 8 )

java.lang.Object
- java.lang.Number
- - java.math.BigDecimal

All Implemented Interfaces:

Serializable ， Comparable < BigDecimal >
```
public class BigDecimal
extends Number
implements Comparable<BigDecimal>
```
不变的，任意精度的带符号的十进制数字。 A BigDecimal由任意精度整数未缩放值和32位整数级别组成 。如果为零或正数，则刻度是小数点右侧的位数。如果是负数，则数字的非标定值乘以10，以达到等级的否定的幂。因此，BigDecimal所代表的BigDecimal值为(unscaledValue × 10^-scale) 。
BigDecimal类提供了算术，缩放操作，舍入，比较，散列和格式转换的操作。 toString()方法提供了一个BigDecimal的规范BigDecimal 。

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

当一个MathContext对象的精度设置为0（例如MathContext.UNLIMITED ）时，算术运算是精确的，而不需要MathContext对象的算术方法也是MathContext 。（这是在5之前版本中支持的唯一行为。）作为计算确切结果的推论，不使用精度设置为0的MathContext对象的舍入模式设置，因此无关紧要。在分割的情况下，精确的商可以具有无限长的十进制扩展; 例如1除以3.如果商具有非终止十进制扩展，并且指定操作返回精确结果，则抛出ArithmeticException 。否则，返回除法的确切结果，与其他操作一样。

当精度设置不为0时， BigDecimal算术的规则与ANSI X3.274-1996和ANSI X3.274-1996 / AM 1-2000（第7.4节）中定义的算法的选定操作模式大体兼容。与这些标准不同， BigDecimal包括许多舍入模式，这些模式在BigDecimal之前的BigDecimal版本中是必须的。这些ANSI标准与BigDecimal规范之间的BigDecimal冲突都被解决为有利于BigDecimal 。

由于相同的数值可以具有不同的表示（具有不同的比例），所以算术和舍入规则必须既指定结果表示中使用的数值结果和比例。

通常，舍入模式和精确度设置决定了当精确结果具有更多数字（在分割的情况下可能无限多））时，操作将返回有限数字的结果，而不是返回的位数。首先，返回的总位数由MathContext的precision设置指定; 这决定了结果的精度。数字计数从精确结果的最左边的非零数字开始。舍入模式确定任何丢弃的尾随数字如何影响返回的结果。

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

除了逻辑精确的结果之外，每个算术运算都具有用于表示结果的优选标度。下表列出了每个操作的首选比例。
Preferred Scales for Results of Arithmetic Operations Operation Preferred Scale of Result Add max(addend.scale(), augend.scale()) Subtract max(minuend.scale(), subtrahend.scale()) Multiply multiplier.scale() + multiplicand.scale() Divide dividend.scale() - divisor.scale()

这些尺度是返回精确算术结果的方法使用的尺度; 除了精确的除法可能需要使用更大的比例，因为确切的结果可能有更多的数字。例如， 1/32是0.03125 。
在舍入前，逻辑精确中间结果的比例是该操作的首选比例。如果确切的数值结果不能在precision数字中表示，则舍入选择要返回的数字集合，并将结果的比例从中间结果的比例减小到precision表示实际返回的precision个数字的最小比例。如果确切的结果可以用最多precision个数字表示，那么返回最接近首选标度的比例的结果的表示。特别地，可以通过删除尾随零和减小刻度来表示精确可表示的商在少于precision个数字中。例如，使用floor舍入模式舍入到三位数字，
19/100 = 0.19 // integer=19, scale=2
但
21/110 = 0.190 // integer=190, scale=3

请注意，对于加法，减法和乘法，缩放比例将等于被丢弃的精确结果的数位数。如果舍入导致进位传播以创建新的高位数字位置，则与没有创建新的数字位置相比，结果的附加数字被丢弃。

其他方法可能略有不同的舍入语义。例如，使用specified algorithm的pow方法的结果偶尔可能与最后一个位置的多个单位的圆形数学结果不同，一个ulp 。

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

为了简洁起见，在BigDecimal方法的描述中使用伪代码。伪代码表达式(i + j)是“a BigDecimal ，其值为BigDecimal i添加到BigDecimal j 。的伪代码表达(i == j)被简写“ true当且仅当所述BigDecimal i表示相同的值作为BigDecimal j ”。类似地解释其他伪代码表达式。方括号用于表示特定的BigInteger和定义BigDecimal值的比例对; 例如[ BigDecimal ]是数字等于0.19的标度为2的BigDecimal 。

注意：如果BigDecimal对象用作BigDecimal中的键或SortedSet中的元素，则应谨慎行事，因为BigDecimal的自然排序 与equals不一致 。见Comparable ， SortedMap或SortedSet以获取更多信息。

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

另请参见：

BigInteger ， MathContext ， RoundingMode ， SortedMap ， SortedSet ， Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`static BigDecimal`	`ONE` 值1，标度为0。
`static int`	`ROUND_CEILING` 圆形模式向正无穷大转弯。
`static int`	`ROUND_DOWN` 舍入模式向零舍入。
`static int`	`ROUND_FLOOR` 舍入模式向负无穷大转弯。
`static int`	`ROUND_HALF_DOWN` 四舍五入模式向“最近邻居”转弯，除非这两个邻居都是等距离的，在这种情况下，这是倒圆的。
`static int`	`ROUND_HALF_EVEN` 四舍五入模式向“最近邻居”转弯，除非两个邻居都是等距离的，在这种情况下，向着邻居方向转移。
`static int`	`ROUND_HALF_UP` 四舍五入模式向“最近邻居”转弯，除非两个邻居都是等距的，在这种情况下是圆括弧的。
`static int`	`ROUND_UNNECESSARY` 舍入模式来确定所请求的操作具有精确的结果，因此不需要舍入。
`static int`	`ROUND_UP` 舍入模式从零开始。
`static BigDecimal`	`TEN` 值为10，标度为0。
`static BigDecimal`	`ZERO` 值为0，标度为0。

构造方法摘要

构造方法
Constructor and Description
`BigDecimal(BigInteger val)` 将 `BigInteger`转换成 `BigDecimal` 。
`BigDecimal(BigInteger unscaledVal, int scale)` 将BigInteger的 `BigInteger`值和 `int`等级转换为 `BigDecimal` 。
`BigDecimal(BigInteger unscaledVal, int scale, MathContext mc)` 将 `BigInteger`未缩放值和 `int`扩展转换为 `BigDecimal` ，根据上下文设置进行舍入。
`BigDecimal(BigInteger val, MathContext mc)` 根据上下文设置将 `BigInteger`转换为 `BigDecimal`舍入。
`BigDecimal(char[] in)` 一个转换的字符数组表示 `BigDecimal`成 `BigDecimal` ，接受字符作为的相同序列 `BigDecimal(String)`构造。
`BigDecimal(char[] in, int offset, int len)` 一个转换的字符数组表示 `BigDecimal`成 `BigDecimal` ，接受字符作为的相同序列 `BigDecimal(String)`构造，同时允许一个子阵列被指定。
`BigDecimal(char[] in, int offset, int len, MathContext mc)` 一个转换的字符数组表示 `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` 。
`BigDecimal(String val, MathContext mc)` 一个转换的字符串表示 `BigDecimal`成 `BigDecimal` ，接受相同的字符串作为 `BigDecimal(String)`构造，利用根据上下文设置进行舍入。

方法摘要

所有方法静态方法接口方法具体的方法
Modifier and Type	Method and Description
`BigDecimal`	`abs()` 返回一个 `BigDecimal` ，其值为此 `BigDecimal`的绝对值，其缩放比例为 `this.scale()` 。
`BigDecimal`	`abs(MathContext mc)` 返回一个 `BigDecimal` ，其值为此 `BigDecimal`的绝对值，根据上下文设置进行舍入。
`BigDecimal`	`add(BigDecimal augend)` 返回 `BigDecimal` ，其值是 `(this + augend)` ，其标为 `max(this.scale(), augend.scale())` 。
`BigDecimal`	`add(BigDecimal augend, MathContext mc)` 返回 `BigDecimal` ，其值是 `(this + augend)` ，根据上下文设置进行舍入。
`byte`	`byteValueExact()` 将此 `BigDecimal`转换为 `byte` ，检查丢失的信息。
`int`	`compareTo(BigDecimal val)` 将此 `BigDecimal`与指定的BigDecimal进行 `BigDecimal` 。
`BigDecimal`	`divide(BigDecimal divisor)` 返回`BigDecimal` ，其值为`(this / divisor)` ，优先级为`(this.scale() - divisor.scale())` ; 如果不能表示确切的商（因为它具有非终止的十进制扩展），则抛出一个`ArithmeticException` 。
`BigDecimal`	`divide(BigDecimal divisor, int roundingMode)` 返回 `BigDecimal` ，其值是 `(this / divisor)` ，其标为 `this.scale()` 。
`BigDecimal`	`divide(BigDecimal divisor, int scale, int roundingMode)` 返回一个 `BigDecimal` ，其值为 `(this / divisor)` ，其比例为指定。
`BigDecimal`	`divide(BigDecimal divisor, int scale, RoundingMode roundingMode)` 返回一个 `BigDecimal` ，其值为 `(this / divisor)` ，其比例为指定。
`BigDecimal`	`divide(BigDecimal divisor, MathContext mc)` 返回 `BigDecimal` ，其值是 `(this / divisor)` ，根据上下文设置进行舍入。
`BigDecimal`	`divide(BigDecimal divisor, RoundingMode roundingMode)` 返回 `BigDecimal` ，其值是 `(this / divisor)` ，其标为 `this.scale()` 。
`BigDecimal[]`	`divideAndRemainder(BigDecimal divisor)` 返回一个两元件 `BigDecimal`阵列含有的结果 `divideToIntegralValue`接着的结果 `remainder`上的两个操作数。
`BigDecimal[]`	`divideAndRemainder(BigDecimal divisor, MathContext mc)` 返回一个两元件 `BigDecimal`阵列含有的结果 `divideToIntegralValue`接着的结果 `remainder`上与根据上下文设置进行舍入计算出的两个操作数。
`BigDecimal`	`divideToIntegralValue(BigDecimal divisor)` 返回一个 `BigDecimal` ，它的值是 `BigDecimal`的整数部分 `(this / divisor)`取整。
`BigDecimal`	`divideToIntegralValue(BigDecimal divisor, MathContext mc)` 返回值为 `BigDecimal`的整数部分的 `(this / divisor)` 。
`double`	`doubleValue()` 将此 `BigDecimal`转换为 `double` 。
`boolean`	`equals(Object x)` 将此 `BigDecimal`与指定的 `Object`进行比较以获得相等性。
`float`	`floatValue()` 将此 `BigDecimal`转换为 `float` 。
`int`	`hashCode()` 返回此 `BigDecimal`的哈希码。
`int`	`intValue()` 将此 `BigDecimal`转换为 `int` 。
`int`	`intValueExact()` 将此 `BigDecimal`转换为 `int` ，检查丢失的信息。
`long`	`longValue()` 将此 `BigDecimal`转换为 `long` 。
`long`	`longValueExact()` 将此 `BigDecimal`转换为 `long` ，检查丢失的信息。
`BigDecimal`	`max(BigDecimal val)` 返回此 `BigDecimal`和 `val` 。
`BigDecimal`	`min(BigDecimal val)` 返回此 `BigDecimal`和 `val` 。
`BigDecimal`	`movePointLeft(int n)` 返回一个 `BigDecimal` ，相当于这个小数点，向左移动了 `n`个地方。
`BigDecimal`	`movePointRight(int n)` 返回一个 `BigDecimal` ，相当于这个小数点移动了 `n`个地方。
`BigDecimal`	`multiply(BigDecimal multiplicand)` 返回 `BigDecimal` ，其值是 `(this × multiplicand)，`其标为 `(this.scale() + multiplicand.scale())` 。
`BigDecimal`	`multiply(BigDecimal multiplicand, MathContext mc)` 返回 `BigDecimal` ，其值是 `(this × multiplicand)，`根据上下文设置进行舍入。
`BigDecimal`	`negate()` 返回 `BigDecimal` ，其值是 `(-this)` ，其标为 `this.scale()` 。
`BigDecimal`	`negate(MathContext mc)` 返回 `BigDecimal` ，其值是 `(-this)` ，根据上下文设置进行舍入。
`BigDecimal`	`plus()` 返回 `BigDecimal` ，其值是 `(+this)` ，其标为 `this.scale()` 。
`BigDecimal`	`plus(MathContext mc)` 返回 `BigDecimal` ，其值是 `(+this)` ，根据上下文设置进行舍入。
`BigDecimal`	`pow(int n)` 返回 `BigDecimal` ，其值是 `(thisⁿ)，`该电源，准确计算，使其具有无限精度。
`BigDecimal`	`pow(int n, MathContext mc)` 返回 `BigDecimal` ，其值是 `(thisⁿ)。`
`int`	`precision()` 返回此 BigDecimal的 `BigDecimal` 。
`BigDecimal`	`remainder(BigDecimal divisor)` 返回 `BigDecimal` ，其值是 `(this % divisor)` 。
`BigDecimal`	`remainder(BigDecimal divisor, MathContext mc)` 返回 `BigDecimal` ，其值是 `(this % divisor)` ，根据上下文设置进行舍入。
`BigDecimal`	`round(MathContext mc)` 返回 `BigDecimal`根据四舍五入 `MathContext`设置。
`int`	`scale()` 返回此规模 `BigDecimal` 。
`BigDecimal`	`scaleByPowerOfTen(int n)` 返回一个BigDecimal，其数值等于（ `this` * 10 ⁿ ）。
`BigDecimal`	`setScale(int newScale)` 返回一个 `BigDecimal` ，其大小是指定值，其值在数字上等于此 `BigDecimal` 。
`BigDecimal`	`setScale(int newScale, int roundingMode)` 返回一个 `BigDecimal` ，其规模是指定值，其缩放值通过将此 `BigDecimal`的非标度值乘以10的适当功率来确定，以维持其总体值。
`BigDecimal`	`setScale(int newScale, RoundingMode roundingMode)` 返回一个 `BigDecimal` ，其规模是指定值，其缩放值通过将该 `BigDecimal`的非标度值乘以10的适当功率来确定，以维持其整体值。
`short`	`shortValueExact()` 将此 `BigDecimal`转换为 `short` ，检查丢失的信息。
`int`	`signum()` 返回这个 `BigDecimal`的signum函数。
`BigDecimal`	`stripTrailingZeros()` 返回一个 `BigDecimal` ，它在数字上等于此值， `BigDecimal`表示中删除任何尾随的零。
`BigDecimal`	`subtract(BigDecimal subtrahend)` 返回 `BigDecimal` ，其值是 `(this - subtrahend)` ，其标为 `max(this.scale(), subtrahend.scale())` 。
`BigDecimal`	`subtract(BigDecimal subtrahend, MathContext mc)` 返回 `BigDecimal` ，其值是 `(this - subtrahend)` ，根据上下文设置进行舍入。
`BigInteger`	`toBigInteger()` 将此 `BigDecimal`转换为 `BigInteger` 。
`BigInteger`	`toBigIntegerExact()` 将此 `BigDecimal`转换为 `BigInteger` ，检查丢失的信息。
`String`	`toEngineeringString()` 如果需要指数，则使用工程符号返回此 `BigDecimal`的字符串表示形式。
`String`	`toPlainString()` 返回没有指数字段的此 `BigDecimal`的字符串表示形式。
`String`	`toString()` 返回此 `BigDecimal`的字符串表示，如果需要指数，则使用科学计数法。
`BigDecimal`	`ulp()` 返回此 `BigDecimal`的最后一个位置的ulp（一个单位）的大小。
`BigInteger`	`unscaledValue()` 返回一个 `BigInteger` ，其值是此 `BigDecimal`的未缩放值。
`static BigDecimal`	`valueOf(double val)` 转换一个 `double`成 `BigDecimal` ，使用 `double`通过所提供的规范的字符串表示 `Double.toString(double)`方法。
`static BigDecimal`	`valueOf(long val)` 将 `long`值转换为 `BigDecimal` ，比例为零。
`static BigDecimal`	`valueOf(long unscaledVal, int scale)` 将 `long`值和 `int`比例转换为 `BigDecimal` 。

Methods inherited from class java.lang.Number
byteValue, shortValue

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- 字段详细信息
  - ZERO
```
public static final BigDecimal ZERO
```
    值为0，标度为0。
    
    从以下版本开始：
    
    1.5
  - ONE
```
public static final BigDecimal ONE
```
    值1，标度为0。
    
    从以下版本开始：
    
    1.5
  - TEN
```
public static final BigDecimal TEN
```
    值为10，标度为0。
    
    从以下版本开始：
    
    1.5
  - ROUND_UP
```
public static final int ROUND_UP
```
    舍入模式从零开始。始终在非零丢弃分数之前增加数字。请注意，该舍入模式不会降低计算值的大小。
    
    另请参见：
    
    Constant Field Values
  - ROUND_DOWN
```
public static final int ROUND_DOWN
```
    舍入模式向零舍入。不要在丢弃的分数之前递增数字（即截断）。请注意，该舍入模式不会增加计算值的大小。
    
    另请参见：
    
    Constant Field Values
  - ROUND_CEILING
```
public static final int ROUND_CEILING
```
    圆形模式向正无穷大转弯。如果BigDecimal为正，则表现为ROUND_UP ; 如果为负，则表现为ROUND_DOWN 。请注意，舍入模式不会降低计算值。
    
    另请参见：
    
    Constant Field Values
  - ROUND_FLOOR
```
public static final int ROUND_FLOOR
```
    舍入模式向负无穷大转弯。如果BigDecimal为正，则表现为ROUND_DOWN ; 如果为负，表现为ROUND_UP 。请注意，舍入模式不会增加计算值。
    
    另请参见：
    
    Constant Field Values
  - ROUND_HALF_UP
```
public static final int ROUND_HALF_UP
```
    四舍五入模式向“最近邻居”转弯，除非两个邻居都是等距的，在这种情况下是圆括弧的。对于ROUND_UP如果丢弃的分数为0.5，则表现为; 否则，表现为ROUND_DOWN 。请注意，这是我们大多数人在小学教学的舍入模式。
    
    另请参见：
    
    Constant Field Values
  - ROUND_HALF_DOWN
```
public static final int ROUND_HALF_DOWN
```
    四舍五入模式向“最近邻居”转弯，除非这两个邻居都是等距离的，在这种情况下，这是倒圆的。对于ROUND_UP如果丢弃的分数> 0.5，则表示行为; 否则，表现为ROUND_DOWN 。
    
    另请参见：
    
    Constant Field Values
  - ROUND_HALF_EVEN
```
public static final int ROUND_HALF_EVEN
```
    四舍五入模式向“最近邻居”转弯，除非两个邻居都是等距离的，在这种情况下，向着邻居方向转移。对于ROUND_HALF_UP行为，如果丢弃的分数的左边的数字是奇数的; 像ROUND_HALF_DOWN一样，如果它是均匀的。请注意，这是在一系列计算中重复应用时最小化累积误差的舍入模式。
    
    另请参见：
    
    Constant Field Values
  - ROUND_UNNECESSARY
```
public static final int ROUND_UNNECESSARY
```
    舍入模式来确定所请求的操作具有精确的结果，因此不需要舍入。如果在产生不精确结果的操作上指定了舍入模式，则抛出ArithmeticException 。
    
    另请参见：
    
    Constant Field Values
- 构造方法详细信息
  - BigDecimal
```
public BigDecimal(char[] in,
                  int offset,
                  int len)
```
    一个转换的字符数组表示BigDecimal成BigDecimal ，接受字符作为的相同序列BigDecimal(String)构造，同时允许一个子阵列被指定。
    请注意，如果字符序列在字符数组中已经可用，则使用此构造函数比将char数组转换为字符串并使用BigDecimal(String)构造函数更快。
    
    参数
    
    in - char数组是字符源。
    
    offset - 要检查的数组中的第一个字符。
    
    len - 要考虑的 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 - 要考虑的 len数
    
    mc - 要使用的上下文。
    
    异常
    
    ArithmeticException - 如果结果不 ArithmeticException ，但舍入方式为 UNNECESSARY 。
    
    NumberFormatException -如果 in不是的有效表示 BigDecimal或所定义的子阵列是不完全内 in 。
    
    从以下版本开始：
    
    1.5
  - BigDecimal
```
public BigDecimal(char[] in)
```
    一个转换的字符数组表示BigDecimal成BigDecimal ，接受字符作为的相同序列BigDecimal(String)构造。
    请注意，如果字符序列已经可用作字符数组，则使用此构造函数比将char数组转换为字符串并使用BigDecimal(String)构造函数更快。
    
    参数
    
    in - char源的数组。
    
    异常
    
    NumberFormatException - 如果 in不是BigDecimal的有效 BigDecimal 。
    
    从以下版本开始：
    
    1.5
  - BigDecimal
```
public BigDecimal(char[] in,
                  MathContext mc)
```
    一个转换的字符数组表示BigDecimal成BigDecimal ，接受相同的字符序列作为BigDecimal(String)构造与根据上下文设置进行舍入。
    请注意，如果字符序列已经可以作为字符数组使用，使用此构造函数比将char数组转换为字符串并使用BigDecimal(String)构造函数更快。
    
    参数
    
    in - char数组是字符源。
    
    mc - 要使用的上下文。
    
    异常
    
    ArithmeticException - 如果结果不 ArithmeticException ，但舍入方式为 UNNECESSARY 。
    
    NumberFormatException - 如果 in不是BigDecimal的有效 BigDecimal 。
    
    从以下版本开始：
    
    1.5
  - BigDecimal
```
public BigDecimal(String val)
```
    将BigDecimal的字符串表示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:
    
    e
    
    E
    
    SignedInteger:
    
    Sign_opt Digits
    
    Digits:
    
    Digit
    
    Digits Digit
    
    Digit:
    
    any character for which Character.isDigit(char) returns true, including 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的字符串 BigDecimal 。
    
    异常
    
    NumberFormatException - 如果 val不是BigDecimal的有效 BigDecimal 。
  - BigDecimal
```
public BigDecimal(String val,
                  MathContext mc)
```
    一个转换的字符串表示 BigDecimal成 BigDecimal ，接受相同的字符串作为 BigDecimal(String)构造，利用根据上下文设置进行舍入。
    
    参数
    
    val - 一个 BigDecimal字符串 BigDecimal 。
    
    mc - 要使用的上下文。
    
    异常
    
    ArithmeticException - 如果结果不 ArithmeticException ，但舍入方式为 UNNECESSARY 。
    
    NumberFormatException - 如果 val不是BigDecimal的有效表示。
    
    从以下版本开始：
    
    1.5
  - BigDecimal
```
public BigDecimal(double val)
```
    将double转换为BigDecimal ，这是double的二进制浮点值的精确十进制表示。返回的BigDecimal是(10^scale × val)是一个整数的最小值。
    笔记：
    1. 这个构造函数的结果可能有些不可预测。可以假设在Java中写入new BigDecimal(0.1)创建一个BigDecimal ，它完全等于0.1（非标尺值为1，比例为1），但实际上等于0.1000000000000000055511151231257827021181583404541015625。这是因为0.1不能像double （或者作为任何有限长度的二进制分数）精确地表示。因此，正在被传递给构造的值不是正好等于0.1，虽然表面上。
    2. 该String构造，在另一方面，是完全可以预测的：写new BigDecimal("0.1")创建BigDecimal这正好等于0.1，正如人们所期望的那样。因此，一般建议使用String constructor优先于此。
    3. 当double必须用作源为BigDecimal ，注意，此构造提供了一个精确的转换; 它不会将double转换为String使用Double.toString(double)方法，然后使用BigDecimal(String)构造函数相同的结果。要获得该结果，请使用static valueOf(double)方法。
    参数
    
    val - double值转换为 BigDecimal 。
    
    异常
    
    NumberFormatException - 如果 val是无限或NaN。
  - BigDecimal
```
public BigDecimal(double val,
                  MathContext mc)
```
    将double转换为BigDecimal ，根据上下文设置进行舍入。 BigDecimal是(10^scale × val)是一个整数的最小值。
    该构造函数的结果可能有些不可预测，一般不推荐使用它; 请参阅BigDecimal(double)构造函数下的注释。
    
    参数
    
    val - double要转换为 BigDecimal值。
    
    mc - 要使用的上下文。
    
    异常
    
    ArithmeticException - 如果结果不正确但RoundingMode是UNNECESSARY。
    
    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 - 要使用的上下文。
    
    异常
    
    ArithmeticException - 如果结果不 ArithmeticException ，但舍入方式为 UNNECESSARY 。
    
    从以下版本开始：
    
    1.5
  - BigDecimal
```
public BigDecimal(BigInteger unscaledVal,
                  int scale)
```
    将BigInteger未BigInteger值和int标度转换为BigDecimal 。 BigDecimal的价值是(unscaledVal × 10^-scale) 。
    
    参数
    
    unscaledVal - unscaledVal值 BigDecimal 。
    
    scale - 规模 BigDecimal 。
  - BigDecimal
```
public BigDecimal(BigInteger unscaledVal,
                  int scale,
                  MathContext mc)
```
    将BigInteger的BigInteger标度值和int标度转换为BigDecimal ，根据上下文设置进行舍入。 BigDecimal值为(unscaledVal × 10^-scale) ，根据precision和舍入模式设置舍入。
    
    参数
    
    unscaledVal - unscaled value的 BigDecimal 。
    
    scale - 规模的 BigDecimal 。
    
    mc - 要使用的上下文。
    
    异常
    
    ArithmeticException - 如果结果不 ArithmeticException ，但舍入方式为 UNNECESSARY 。
    
    从以下版本开始：
    
    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 - 要使用的上下文。
    
    异常
    
    ArithmeticException - 如果结果不 ArithmeticException ，但舍入方式为 UNNECESSARY 。
    
    从以下版本开始：
    
    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 - 要使用的上下文。
    
    异常
    
    ArithmeticException - 如果结果不 ArithmeticException ，但舍入方式为 UNNECESSARY 。
    
    从以下版本开始：
    
    1.5
- 方法详细信息
  - valueOf
```
public static BigDecimal valueOf(long unscaledVal,
                                 int scale)
```
    将long未缩放值和int量表转换为BigDecimal 。优先提供给（在此“静态工厂法” long ， int ）构造，因为它允许使用频率重用BigDecimal值..
    
    参数
    
    unscaledVal -的的非标度值 BigDecimal 。
    
    scale - 规模的 BigDecimal 。
    
    结果
    
    一个 BigDecimal的值是 (unscaledVal × 10^-scale) 。
  - valueOf
```
public static BigDecimal valueOf(long val)
```
    将long值转换为BigDecimal ，缩放为零。这种“静态工厂方法”优先于（ long ）构造函数，因为它允许重用常用的BigDecimal值。
    
    参数
    
    val - 的价值 BigDecimal 。
    
    结果
    
    一个 BigDecimal的值是 val 。
  - valueOf
```
public static BigDecimal valueOf(double val)
```
    转换一个double成BigDecimal ，使用double通过所提供的规范的字符串表示Double.toString(double)方法。
    注意：这通常是转换的首选方法double （或float ）成BigDecimal ，作为返回的值等于从构建所得BigDecimal使用的结果Double.toString(double) 。
    
    参数
    
    val - double转换为 BigDecimal 。
    
    结果
    
    一个 BigDecimal ，其值等于或约等于的值 val 。
    
    异常
    
    NumberFormatException - 如果 val是无限或NaN。
    
    从以下版本开始：
    
    1.5
  - add
```
public BigDecimal add(BigDecimal augend)
```
    返回 BigDecimal ，其值是 (this + augend) ，其标为 max(this.scale(), augend.scale()) 。
    
    参数
    
    augend - 要添加到此 BigDecimal 。
    
    结果
    
    this + augend
  - add
```
public BigDecimal add(BigDecimal augend,
                      MathContext mc)
```
    返回BigDecimal ，其值是(this + augend) ，根据上下文设置进行舍入。如果任一数字为零，并且精度设置为非零，则使用其他数字（如果需要舍入）作为结果。
    
    参数
    
    augend - 要添加到此 BigDecimal 。
    
    mc - 要使用的上下文。
    
    结果
    
    this + augend ，根据需要舍入。
    
    异常
    
    ArithmeticException - 如果结果不 ArithmeticException ，但舍入方式为 UNNECESSARY 。
    
    从以下版本开始：
    
    1.5
  - subtract
```
public BigDecimal subtract(BigDecimal subtrahend)
```
    返回 BigDecimal ，其值是 (this - subtrahend) ，其标为 max(this.scale(), subtrahend.scale()) 。
    
    参数
    
    subtrahend - 要从该 BigDecimal 。
    
    结果
    
    this - subtrahend
  - subtract
```
public BigDecimal subtract(BigDecimal subtrahend,
                           MathContext mc)
```
    返回BigDecimal ，其值是(this - subtrahend) ，根据上下文设置进行舍入。如果subtrahend为零，则作为结果使用，如果需要，则舍入。如果这是零，那么结果是subtrahend.negate(mc) 。
    
    参数
    
    subtrahend - 要从该 BigDecimal 。
    
    mc - 要使用的上下文。
    
    结果
    
    this - subtrahend ， this - subtrahend时舍入。
    
    异常
    
    ArithmeticException - 如果结果不 UNNECESSARY但舍入方式为 UNNECESSARY 。
    
    从以下版本开始：
    
    1.5
  - multiply
```
public BigDecimal multiply(BigDecimal multiplicand)
```
    返回 BigDecimal ，其值是 (this × multiplicand)，其标为 (this.scale() + multiplicand.scale()) 。
    
    参数
    
    multiplicand -价值被这个乘以 BigDecimal 。
    
    结果
    
    this * multiplicand
  - multiply
```
public BigDecimal multiply(BigDecimal multiplicand,
                           MathContext mc)
```
    返回 BigDecimal ，其值是 (this × multiplicand)，根据上下文设置进行舍入。
    
    参数
    
    multiplicand -价值被这个乘以 BigDecimal 。
    
    mc - 要使用的上下文。
    
    结果
    
    this * multiplicand ， this * multiplicand时舍入。
    
    异常
    
    ArithmeticException - 如果结果不 ArithmeticException ，但舍入方式为 UNNECESSARY 。
    
    从以下版本开始：
    
    1.5
  - divide
```
public BigDecimal divide(BigDecimal divisor,
                         int scale,
                         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
  - 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
```
public BigDecimal divide(BigDecimal divisor,
                         int roundingMode)
```
    返回BigDecimal ，其值是(this / divisor) ，其标为this.scale() 。如果必须执行舍入以产生给定刻度的结果，则应用指定的舍入模式。
    应该使用新的divide(BigDecimal, RoundingMode)方法优先于此传统方法。
    
    参数
    
    divisor - 这个 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
  - divide
```
public BigDecimal divide(BigDecimal divisor,
                         RoundingMode roundingMode)
```
    返回BigDecimal ，其值是(this / divisor) ，其标为this.scale() 。如果必须执行舍入以产生给定刻度的结果，则应用指定的舍入模式。
    
    参数
    
    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)
```
    返回 BigDecimal ，其值是 (this / divisor) ，根据上下文设置进行舍入。
    
    参数
    
    divisor - 这个 BigDecimal将被划分的值。
    
    mc - 要使用的上下文。
    
    结果
    
    this / divisor ， this / divisor时舍入。
    
    异常
    
    ArithmeticException - 如果结果不 ArithmeticException ，但舍入方式为 UNNECESSARY或 mc.precision == 0 ，商为非终止十进制扩展。
    
    从以下版本开始：
    
    1.5
  - divideToIntegralValue
```
public BigDecimal divideToIntegralValue(BigDecimal divisor)
```
    返回一个BigDecimal ，其值是(this / divisor)舍入的商(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()) 。一个ArithmeticException如果准确的商值的整数部分需要超过抛出mc.precision数字。
    
    参数
    
    divisor - 这个 BigDecimal要被划分的值。
    
    mc - 要使用的上下文。
    
    结果
    
    this / divisor的整数部分。
    
    异常
    
    ArithmeticException - 如果 divisor==0
    
    ArithmeticException - 如果 mc.precision > 0，并且结果需要大于 mc.precision位数的精度。
    
    从以下版本开始：
    
    1.5
  - remainder
```
public BigDecimal remainder(BigDecimal divisor)
```
    返回BigDecimal ，其值是(this % divisor) 。
    余数由this.subtract(this.divideToIntegralValue(divisor).multiply(divisor)) 。请注意，这不是模运算（结果可以是负数）。
    
    参数
    
    divisor - 这个 BigDecimal要被划分的值。
    
    结果
    
    this % divisor 。
    
    异常
    
    ArithmeticException - 如果 divisor==0
    
    从以下版本开始：
    
    1.5
  - remainder
```
public BigDecimal remainder(BigDecimal divisor,
                            MathContext mc)
```
    返回BigDecimal ，其值是(this % divisor) ，根据上下文设置进行舍入。 MathContext设置影响用于计算余数的隐含分隔。其余的计算本身就是按照准确的。因此，其余可能包含超过mc.getPrecision()个数字。
    余数由this.subtract(this.divideToIntegralValue(divisor, mc).multiply(divisor)) 。请注意，这不是模运算（结果可以是负数）。
    
    参数
    
    divisor - 这个 BigDecimal将被划分的值。
    
    mc - 要使用的上下文。
    
    结果
    
    this % divisor ， this % divisor时舍入。
    
    异常
    
    ArithmeticException - 如果 divisor==0
    
    ArithmeticException - 如果结果不准确，但舍入方式为 UNNECESSARY ，或 mc.precision > 0，而 this.divideToIntgralValue(divisor)的结果将要求精度高于 mc.precision位数。
    
    从以下版本开始：
    
    1.5
    
    另请参见：
    
    divideToIntegralValue(java.math.BigDecimal, java.math.MathContext)
  - divideAndRemainder
```
public BigDecimal[] divideAndRemainder(BigDecimal divisor)
```
    返回一个两元件BigDecimal阵列含有的结果divideToIntegralValue接着的结果remainder上的两个操作数。
    注意，如果需要整数商和余数，该方法比divideToIntegralValue使用divideToIntegralValue和remainder方法更快，因为除法只需要执行一次。
    
    参数
    
    divisor - 这个 BigDecimal要被划分的值， BigDecimal是计算的。
    
    结果
    
    一个二元素 BigDecimal数组：商（ divideToIntegralValue的结果）是初始元素，余数是最后一个元素。
    
    异常
    
    ArithmeticException - 如果是 divisor==0
    
    从以下版本开始：
    
    1.5
    
    另请参见：
    
    divideToIntegralValue(java.math.BigDecimal, java.math.MathContext) ， remainder(java.math.BigDecimal, java.math.MathContext)
  - divideAndRemainder
```
public BigDecimal[] divideAndRemainder(BigDecimal divisor,
                                       MathContext mc)
```
    返回一个两元件BigDecimal阵列含有的结果divideToIntegralValue接着的结果remainder上与根据上下文设置进行舍入计算出的两个操作数。
    请注意，如果需要整数商和余数，则该方法比divideToIntegralValue使用divideToIntegralValue和remainder方法更快，因为除法仅需执行一次。
    
    参数
    
    divisor - 这个 BigDecimal要被划分的值， BigDecimal是计算的。
    
    mc - 要使用的上下文。
    
    结果
    
    一个二元素 BigDecimal数组：商（ divideToIntegralValue的结果）是初始元素，余数是最后一个元素。
    
    异常
    
    ArithmeticException - 如果是 divisor==0
    
    ArithmeticException - 如果结果不 UNNECESSARY ，但舍入模式为 UNNECESSARY ，或 mc.precision > 0，并且 this.divideToIntgralValue(divisor)的结果将需要大于 mc.precision位数的精度。
    
    从以下版本开始：
    
    1.5
    
    另请参见：
    
    divideToIntegralValue(java.math.BigDecimal, java.math.MathContext) ， remainder(java.math.BigDecimal, java.math.MathContext)
  - pow
```
public BigDecimal pow(int n)
```
    返回BigDecimal ，其值是(thisⁿ)，该电源，准确计算，使其具有无限精度。
    参数n的范围必须在0到999999999之间。 ZERO.pow(0)返回ONE 。请注意，将来的版本可能会扩大此方法的允许指数范围。
    
    参数
    
    n - 提高这 BigDecimal 。
    
    结果
    
    thisⁿ
    
    异常
    
    ArithmeticException - 如果 n超出范围。
    
    从以下版本开始：
    
    1.5
  - pow
```
public BigDecimal pow(int n,
                      MathContext mc)
```
    返回BigDecimal ，其值是(thisⁿ)。 目前的实现使用ANSI标准X3.274-1996中定义的核心算法，根据上下文设置进行舍入。通常，返回的数值在所选精度的精确数值的两个ul内。请注意，未来的版本可能会使用不同的算法，减少了允许的误差范围和增加的允许指数范围。
    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为阳性; 然后使用上述工作精度将该值分为一个。
      
      然后将正值或负数情况下的最终值四舍五入为目标精度。
    参数
    
    n - 提高这个 BigDecimal 。
    
    mc - 要使用的上下文。
    
    结果
    
    thisⁿ使用ANSI标准X3.274-1996算法
    
    异常
    
    ArithmeticException - 如果结果不 UNNECESSARY ，但舍入方式为 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) ， abs(this)时舍入。
    
    异常
    
    ArithmeticException - 如果结果不 ArithmeticException ，但舍入方式为 UNNECESSARY 。
    
    从以下版本开始：
    
    1.5
  - negate
```
public BigDecimal negate()
```
    返回 BigDecimal ，其值是 (-this) ，其标为 this.scale() 。
    
    结果
    
    -this 。
  - negate
```
public BigDecimal negate(MathContext mc)
```
    返回 BigDecimal ，其值是 (-this) ，根据上下文设置进行舍入。
    
    参数
    
    mc - 要使用的上下文。
    
    结果
    
    -this ， -this时舍入。
    
    异常
    
    ArithmeticException - 如果结果不 ArithmeticException ，但舍入方式为 UNNECESSARY 。
    
    从以下版本开始：
    
    1.5
  - plus
```
public BigDecimal plus()
```
    返回BigDecimal ，其值是(+this) ，其标为this.scale() 。
    这个方法，简单地返回这个BigDecimal包含与一元负方法negate()的对称性。
    
    结果
    
    this 。
    
    从以下版本开始：
    
    1.5
    
    另请参见：
    
    negate()
  - plus
```
public BigDecimal plus(MathContext mc)
```
    返回BigDecimal ，其值是(+this) ，根据上下文设置进行舍入。
    该方法的效果与round(MathContext)方法的效果相同。
    
    参数
    
    mc - 要使用的上下文。
    
    结果
    
    this ，根据需要舍入。零结果将具有0的比例。
    
    异常
    
    ArithmeticException - 如果结果不精确但是舍入模式是 UNNECESSARY 。
    
    从以下版本开始：
    
    1.5
    
    另请参见：
    
    round(MathContext)
  - signum
```
public int signum()
```
    返回这个 BigDecimal的signum函数。
    
    结果
    
    -1，0或1，因为此 BigDecimal值为负，零或正。
  - scale
```
public int scale()
```
    返回此规模 BigDecimal 。如果为零或正数，则刻度是小数点右侧的位数。如果是负数，则数字的非标定值乘以10，以达到等级的否定的幂。例如， -3的比例表示未标定值乘以1000。
    
    结果
    
    这个规模这个 BigDecimal 。
  - precision
```
public int precision()
```
    返回此BigDecimal的BigDecimal 。（精度是未缩放值的位数）
    零值的精度为1。
    
    结果
    
    这个BigDecimal的 BigDecimal 。
    
    从以下版本开始：
    
    1.5
  - unscaledValue
```
public BigInteger unscaledValue()
```
    返回一个BigInteger ，其值是此BigDecimal的未缩放值 。（计算(this * 10^this.scale()) ）
    
    结果
    
    这个 BigDecimal价值。
    
    从以下版本开始：
    
    1.2
  - round
```
public BigDecimal round(MathContext mc)
```
    根据MathContext设置返回一个BigDecimal四舍五入。如果精度设置为0，则不进行舍入。
    该方法的效果与plus(MathContext)方法的效果相同。
    
    参数
    
    mc - 要使用的上下文。
    
    结果
    
    一个 BigDecimal根据 MathContext设置舍入。
    
    异常
    
    ArithmeticException - 如果舍入模式为 UNNECESSARY ，并且 BigDecimal操作将需要舍入。
    
    从以下版本开始：
    
    1.5
    
    另请参见：
    
    plus(MathContext)
  - setScale
```
public BigDecimal setScale(int newScale,
                           RoundingMode roundingMode)
```
    返回一个BigDecimal ，其大小是指定的值，并且其取消的值通过将此BigDecimal的非标度值乘以10的适当功率来确定，以维持其整体值。如果通过操作缩小比例，则将非标定值除以（而不是乘以），并且该值可能会被更改; 在这种情况下，指定的舍入模式被应用于该划分。
    请注意，由于BigDecimal对象是不可变的，所以此方法的调用不会导致原始对象被修改，这与通常使用名为setX mutate字段X方法X 。相反， setScale返回具有适当比例的对象; 返回的对象可能会被新分配，也可能不会被新分配。
    
    参数
    
    newScale - 要退回的 BigDecimal值的比例。
    
    roundingMode - 要应用的舍入模式。
    
    结果
    
    一个 BigDecimal ，其规模是指定值，并且其缩放值通过将此 BigDecimal的非标度值乘以10的适当功率来确定，以维持其总体值。
    
    异常
    
    ArithmeticException - 如果 roundingMode==UNNECESSARY和指定的缩放操作将需要四舍五入。
    
    从以下版本开始：
    
    1.5
    
    另请参见：
    
    RoundingMode
  - setScale
```
public BigDecimal setScale(int newScale,
                           int roundingMode)
```
    返回一个BigDecimal ，其大小是指定的值，并且其缩放值通过将此BigDecimal的非标度值乘以10的适当功率来确定，以维持其整体值。如果通过操作缩小比例，则将非标定值除以（而不是乘以），并且该值可能会被更改; 在这种情况下，指定的舍入模式被应用于该划分。
    请注意，由于BigDecimal对象是不可变的，所以此方法的调用不会导致原始对象被修改，这与通常使用名为setX mutate字段X方法X 。相反， setScale返回具有适当比例的对象; 返回的对象可能会被新分配，也可能不会被新分配。
    
    应该使用新的setScale(int, RoundingMode)方法来优先于这种传统方法。
    
    参数
    
    newScale - 要退回的 BigDecimal值的比例。
    
    roundingMode - 要应用的舍入模式。
    
    结果
    
    一个 BigDecimal ，其规模是指定值，并且其缩放值通过将该 BigDecimal的非标度值乘以10的适当功率来确定，以维持其总体值。
    
    异常
    
    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
  - setScale
```
public BigDecimal setScale(int newScale)
```
    返回一个BigDecimal ，其大小是指定的值，其值在数字上等于此BigDecimal 。抛出一个ArithmeticException如果这是不可能的。
    此调用通常用于增加比例，在这种情况下，可以确保存在指定BigDecimal的BigDecimal和正确的值。如果调用者知道BigDecimal在其小数部分结尾处具有足够多的零（即，其整数值中的十个因子）以允许重新调整而不改变其值，那么该调用也可以用于减小比例。
    
    该方法返回与setScale的双参数版本相同的结果，但是在不相关的情况下，会保存调用者指定舍入模式的麻烦。
    
    注意，由于BigDecimal对象是不可变的，所以这种方法的调用不会导致原始对象被修改，这与通常使用名为setX mutate字段X方法X 。相反， setScale返回具有适当比例的对象; 返回的对象可能会被新分配，也可能不会被新分配。
    
    参数
    
    newScale - 要退回的 BigDecimal值的比例。
    
    结果
    
    一个 BigDecimal ，其规模是指定值，其非标度值通过将此 BigDecimal的非标度值乘以10的适当功率来确定，以维持其总体值。
    
    异常
    
    ArithmeticException - 如果指定的缩放操作需要舍入。
    
    另请参见：
    
    setScale(int, int) ， setScale(int, RoundingMode)
  - movePointLeft
```
public BigDecimal movePointLeft(int n)
```
    返回一个BigDecimal ，相当于这个小数点n个地方。如果n是非负数，则调用仅将n添加到比例。如果n为负，则该呼叫相当于movePointRight(-n) 。此呼叫返回的BigDecimal具有值(this × 10^-n)和scale max(this.scale()+n, 0) 。
    
    参数
    
    n - 将小数点向左移动的位数。
    
    结果
    
    一个 BigDecimal相当于这个与小数点 n个地方。
    
    异常
    
    ArithmeticException - 如果比例溢出。
  - movePointRight
```
public BigDecimal movePointRight(int n)
```
    返回一个BigDecimal ，相当于这个小数点，向右移动了n个地方。如果n是非负数，则调用仅从标度中减去n 。如果n为负数，则该呼叫相当于movePointLeft(-n) 。此呼叫返回的BigDecimal值为(this × 10ⁿ)和scale max(this.scale()-n, 0) 。
    
    参数
    
    n - 将小数点向右移动的位数。
    
    结果
    
    一个 BigDecimal相当于这个与小数点移动的位置在右边的 n 。
    
    异常
    
    ArithmeticException - 如果比例溢出。
  - scaleByPowerOfTen
```
public BigDecimal scaleByPowerOfTen(int n)
```
    返回一个BigDecimal，其数值等于（ this * 10 ⁿ ）。结果的比例为(this.scale() - n) 。
    
    参数
    
    n - 十个指数幂的比例
    
    结果
    
    其数值等于（ this * 10 ⁿ ）的 this
    
    异常
    
    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 ，任何尾随零被删除。
    
    从以下版本开始：
    
    1.5
  - compareTo
```
public int compareTo(BigDecimal val)
```
    将此BigDecimal与指定的BigDecimal进行BigDecimal 。两个BigDecimal对象的价值相等但具有不同的比例（如2.0和2.00）被认为是相等的这种方法。该方法优先于六个布尔比较运算符（<，==，>，> =，！=，<=）中的每一个的各个方法。用于执行这些比较的建议成语是： (x.compareTo(y) < op > 0) ，其中< op >是六个比较运算符之一。
    
    Specified by:
    
    compareTo中的 Comparable<BigDecimal>
    
    参数
    
    val - BigDecimal ，对此 BigDecimal进行比较。
    
    结果
    
    -1,0或1，因为这个 BigDecimal在数字上小于，等于或大于 val 。
  - equals
```
public boolean equals(Object x)
```
    将此BigDecimal与指定的Object进行比较以获得相等性。与compareTo不同，该方法认为两个BigDecimal对象只有在值和比例相等时才相等（因此，当通过此方法比较时，2.0不等于2.00）。
    
    重写：
    
    equals在 Object
    
    参数
    
    x - Object要对这 BigDecimal进行比较。
    
    结果
    
    true当且仅当指定的 Object为 BigDecimal ，其值和比例等于该 BigDecimal的时候。
    
    另请参见：
    
    compareTo(java.math.BigDecimal) ， hashCode()
  - min
```
public BigDecimal min(BigDecimal val)
```
    返回此 BigDecimal和 val 。
    
    参数
    
    val - 要计算最小值的值。
    
    结果
    
    该BigDecimal的价值是该BigDecimal和val较小的一个。如果它们相同，则由compareTo方法定义，则返回this 。
    
    另请参见：
    
    compareTo(java.math.BigDecimal)
  - max
```
public BigDecimal max(BigDecimal val)
```
    返回此 BigDecimal和 val 。
    
    参数
    
    val - 要计算最大值的值。
    
    结果
    
    其BigDecimal的价值是该BigDecimal和val中的较大val 。如果它们相同，则由compareTo方法定义，则返回this 。
    
    另请参见：
    
    compareTo(java.math.BigDecimal)
  - hashCode
```
public int hashCode()
```
    返回此BigDecimal的哈希码。请注意，两个BigDecimal对象在数字上相等但尺度不同（如2.0和2.00）通常不会有相同的哈希码。
    
    重写：
    
    hashCode在 Object
    
    结果
    
    这个 BigDecimal哈希码。
    
    另请参见：
    
    equals(Object)
  - toString
```
public String toString()
```
    返回此BigDecimal的字符串表示形式，如果需要指数则使用科学记数法。
    通过以下步骤创建BigDecimal标准规范字符串形式：首先，BigDecimal的未缩放值的BigDecimal将转换为字符串，使用字符'0'至'9' ，不带前导零（除其值为零，在这种情况下使用单个'0'字符）。
    
    接下来，计算调整后的指数 ; 这是否定的比例，加上转换后的未标定值的字符数少于1。也就是说， -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值与此转换的结果之间存在一对一映射。也就是说，作为使用toString的结果，每个可区分的BigDecimal值（非标度值和比例）都有唯一的字符串表示形式。如果该字符串表示转换回BigDecimal使用BigDecimal(String)构造，则原始值将被回收。
    2. 给定数字产生的字符串总是相同的; 它不受区域设置的影响。这意味着它可以用作交换十进制数据的标准字符串表示形式，也可以用作Hashtable等的键。区域设置敏感数字格式化和解析由NumberFormat类及其子类来处理。
    3. toEngineeringString()方法可用于以工程符号表示数字，并且setScale方法可用于对BigDecimal进行舍入，因此它具有小数点后的已知数字位数。
    4. 所提供的数字到字符映射Character.forDigit被使用。
    重写：
    
    toString在 Object
    
    结果
    
    这个 BigDecimal字符串表示 BigDecimal 。
    
    另请参见：
    
    Character.forDigit(int, int) ， BigDecimal(java.lang.String)
  - toEngineeringString
```
public String toEngineeringString()
```
    如果需要指数，则使用工程符号返回此BigDecimal的字符串表示形式。
    返回一个表示toString()方法中描述的BigDecimal的字符串，但如果使用指数符号，则将十的幂调整为三（工程符号）的倍数，使得非零值的整数部分将位于范围1到999.如果指数符号用于零值，则使用小数点和一个或两个小数零数字，以保持零值的比例。注意，与输出toString() ，这种方法的输出是不能保证恢复相同[整数，标度]对本的BigDecimal如果输出串转换回一个BigDecimal使用string constructor 。该方法的结果满足了通过将字符串构造函数应用于方法的输出来总是产生数值相等的结果的较弱约束。
    
    结果
    
    这个 BigDecimal字符串表示法，如果需要指数，则使用工程符号。
    
    从以下版本开始：
    
    1.5
  - toPlainString
```
public String toPlainString()
```
    返回没有指数字段的BigDecimal的字符串表示形式。对于正比例的值，小数点右侧的位数用于表示比例。对于零或负比例的值，生成的字符串就像将值转换为数字相等的零标度值一样生成，并且如果零比例值的所有尾部零都存在于结果中。如果未缩放的值小于零，则整个字符串前加一个减号字符' - '（ '\u002D' ）。如果未标定值为零或正数，则不会标记符号。注意，如果该方法的结果被传递到string constructor ，仅此的数值BigDecimal将必然被回收; 新的BigDecimal可能有不同的比例。特别地，如果这个BigDecimal具有负比例尺，则由该方法生成的字符串将在字符串构造函数处理时具有0的比例。（该方法类似于1.4和更早版本中的toString方法。）
    
    结果
    
    这个没有指数字段的 BigDecimal的字符串表示。
    
    从以下版本开始：
    
    1.5
    
    另请参见：
    
    toString() ， toEngineeringString()
  - toBigInteger
```
public BigInteger toBigInteger()
```
    将此BigDecimal转换为BigInteger 。此转换类似于从基本收缩转换 double至long如在章节的The Java™ Language Specification 5.1.3定义：此的任何小数部分BigDecimal将被丢弃。请注意，此转换可能会丢失有关BigDecimal的BigDecimal 。
    如果转换不正确（换句话说，如果非零小数部分被丢弃），则抛出异常，请使用toBigIntegerExact()方法。
    
    结果
    
    这 BigDecimal转换成 BigInteger 。
  - toBigIntegerExact
```
public BigInteger toBigIntegerExact()
```
    将此BigDecimal转换为BigInteger ，检查丢失的信息。如果此BigDecimal具有非零小数部分，则抛出异常。
    
    结果
    
    这 BigDecimal转换为 BigInteger 。
    
    异常
    
    ArithmeticException - 如果 this具有非零分数部分。
    
    从以下版本开始：
    
    1.5
  - longValue
```
public long longValue()
```
    将此BigDecimal转换为long 。此转换类似于从基本收缩转换 double至short如在The Java™ Language Specification部分5.1.3中定义：此的任何小数部分BigDecimal将被丢弃，并且如果产生的“ BigInteger ”太大而不适合在一个long ，只返回低位64位。请注意，此转换可能会丢失有关该BigDecimal值的总体大小和精度的信息，并返回相反的结果。
    
    Specified by:
    
    longValue在 Number
    
    结果
    
    这 BigDecimal转换成 long 。
  - longValueExact
```
public long longValueExact()
```
    将此BigDecimal转换为long ，检查丢失的信息。如果此BigDecimal具有非零小数部分，或者超出了long结果的可能范围，则抛出ArithmeticException 。
    
    结果
    
    这 BigDecimal转换成 long 。
    
    异常
    
    ArithmeticException - 如果 this具有非零分数部分，或者不适合 long 。
    
    从以下版本开始：
    
    1.5
  - intValue
```
public int intValue()
```
    将此BigDecimal转换为int 。此转换类似于从基本收缩转换 double至short如在The Java™ Language Specification部分5.1.3中定义：此的任何小数部分BigDecimal将被丢弃，并且如果产生的“ BigInteger ”太大而不适合用int ，只返回低位32位。请注意，此转换可能会丢失有关此BigDecimal值的总体大小和精度的信息，并返回相反符号的结果。
    
    Specified by:
    
    intValue在 Number
    
    结果
    
    这 BigDecimal转换成 int 。
  - 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如在章节的The Java™ Language Specification 5.1.3定义：如果此BigDecimal有太大的幅度来表示作为float ，它会被转换为Float.NEGATIVE_INFINITY或Float.POSITIVE_INFINITY适当。请注意，即使返回值有限，此转换也可能会丢失有关BigDecimal值的BigDecimal 。
    
    Specified by:
    
    floatValue在 Number
    
    结果
    
    这 BigDecimal转换成 float 。
  - doubleValue
```
public double doubleValue()
```
    将此BigDecimal转换为double 。这种转换是类似于从基本收缩转换 double至float如在章节的The Java™ Language Specification 5.1.3定义：如果此BigDecimal有太大的幅度代表作为double ，它会被转换为Double.NEGATIVE_INFINITY或Double.POSITIVE_INFINITY适当。请注意，即使返回值有限，此转换也可能会丢失有关BigDecimal的BigDecimal 。
    
    Specified by:
    
    doubleValue在 Number
    
    结果
    
    这 BigDecimal转换成 double 。
  - ulp
```
public BigDecimal ulp()
```
    返回此BigDecimal的最后一个单位的ulp的大小。非零BigDecimal值的ulp是该值与BigDecimal值之间的正距离，接下来的数字大小相同，数字相同。零值的数值在数字上等于1，标度为this 。结果以与this相同的比例存储，因此零和非零值的结果等于[1, this.scale()] 。
    
    结果
    
    大小的ulp为 this
    
    从以下版本开始：
    
    1.5

Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2014, Oracle and/or its affiliates. All rights reserved.

Class BigDecimal

Field Summary

构造方法摘要

方法摘要

Methods inherited from class java.lang.Number

Methods inherited from class java.lang.Object

字段详细信息

ZERO

ONE

TEN

ROUND_UP

ROUND_DOWN

ROUND_CEILING

ROUND_FLOOR

ROUND_HALF_UP

ROUND_HALF_DOWN

ROUND_HALF_EVEN

ROUND_UNNECESSARY

构造方法详细信息

BigDecimal

BigDecimal

BigDecimal

BigDecimal

BigDecimal

BigDecimal

BigDecimal

BigDecimal

BigDecimal

BigDecimal

BigDecimal

BigDecimal

BigDecimal

BigDecimal

BigDecimal

BigDecimal

方法详细信息

valueOf

valueOf

valueOf

add

add

subtract

subtract

multiply

multiply

divide

divide

divide

divide

divide

divide

divideToIntegralValue

divideToIntegralValue

remainder

remainder

divideAndRemainder

divideAndRemainder

pow

pow

abs

abs

negate

negate

plus

plus

signum

scale

precision

unscaledValue

round

setScale

setScale

setScale

movePointLeft

movePointRight

scaleByPowerOfTen

stripTrailingZeros

compareTo

equals

min