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>

不可变的，任意精度有符号的十进制数。一个 BigDecimal由任意精度的整数和一个32位的整数规模不成比例的价值。如果零或正，规模是小数点右边的数字的位数。如果负的数量不成比例的值乘以十规模的否定的力量。由 BigDecimal代表数的价值因此是 (unscaledValue × 10^-scale)。由方法返回精确的运算结果用的是

BigDecimal类的算术，尺度操纵，圆、比较、散列提供的操作，和格式转换。的toString()方法提供的一个典型代表，一个BigDecimal。

该类提供了BigDecimal舍入行为的用户完全控制。如果没有指定舍入模式，无法表示准确结果，则抛出一个异常；否则，计算可以进行选择的精度和舍入模式的操作提供适当的MathContext对象。在两种情况下，提供了八种四舍五入模式，以控制四舍五入。在这类使用整数字段（如ROUND_HALF_UP）为代表的舍入模式已经过时；的RoundingMode 枚举枚举值，（如RoundingMode.HALF_UP）应该用来代替。

当一个MathContext对象提供0的精度设置（例如，MathContext.UNLIMITED），算术运算是准确的，因为是算术方法是不MathContext对象。（这是唯一的行为，在之前的5版本支持）作为计算结果的舍入模式具有0的精度设置MathContext对象设置不使用，因此无关。在分裂的情况下，确切的商可以有一个无限长的十进制扩展；例如，1除以3。如果商具有无穷的十进制扩展和操作指定返回准确的结果，一个ArithmeticException抛出。否则，返回的确切结果，为其他操作所做的。

当精度设置不0，对BigDecimal算法规则是广泛兼容的可选操作模式中定义的算法x3.274-1996和ANSI ANSI X3.274-1996/AM 1-2000（7.4节）。不像那些标准，BigDecimal包括多种舍入模式，分别为司BigDecimal强制性5之前的版本。这些ANSI标准和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位数去除尾随零和减少规模为代表。例如，使用floor取整舍入模式为三位数，
19/100 = 0.19 // integer=19, scale=2
but
21/110 = 0.190 // integer=190, scale=3

请注意，对于添加、减去和乘，规模的减少将等于被丢弃的确切结果的数字位置的数量。如果四舍五入导致进位传播，以创建一个新的高阶数位位置，则当创建一个新的数位位置时，会被丢弃的结果的一个额外的数位被丢弃。

其他方法可能有稍微不同的四舍五入语义。例如，使用specified algorithm的pow方法的结果有时不同于圆的数学结果，最后超过一个单位，一个小。

两类运算提供了操纵的BigDecimal规模：缩放/舍入运算和小数点移动操作。缩放/舍入操作（setScale和round）返回一个BigDecimal其值大约是（或完全）等于该数，但其规模和精度是指定的值；即他们增加或存储数的精度对其价值的影响最小的减少。小数点移动操作（movePointLeft和movePointRight）返回一个BigDecimal移动小数点在指定的方向指定的距离从数了。

为了清晰、明了，伪代码是在BigDecimal描述的使用方法。伪代码表达(i + j)是“BigDecimal其价值的BigDecimal i添加到的BigDecimal j速记。“伪码表达(i == j)是“true若BigDecimal i表示相同的值作为BigDecimal j速记。”类似地解释其他伪代码表达式。方括号来表示特定的BigInteger和规模对定义BigDecimal值；例如，[ 19，2 ]是BigDecimal在数值上等于0.19，规模2。

注：应注意如果BigDecimal对象是作为自BigDecimal的自然排序是不致在SortedSet一SortedMap或元素的键。看到Comparable，SortedMap或SortedSet更多信息。

这个类的所有方法和构造函数抛出NullPointerException时通过的任何输入参数null对象引用。

另请参见：: 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)` 翻译成 `BigDecimal` `BigInteger`。
`BigDecimal(BigInteger unscaledVal, int scale)` 翻译 `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)` 翻译成 `BigDecimal` `double`的 `double`二进制浮点值的小数表示。
`BigDecimal(double val, MathContext mc)` 翻译 `double`成 `BigDecimal`，舍入根据语境的设置。
`BigDecimal(int val)` 翻译成 `BigDecimal` `int`。
`BigDecimal(int val, MathContext mc)` 翻译 `int`成 `BigDecimal`，舍入根据语境的设置。
`BigDecimal(long val)` 翻译成 `BigDecimal` `long`。
`BigDecimal(long val, MathContext mc)` 翻译 `long`成 `BigDecimal`，舍入根据语境的设置。
`BigDecimal(String val)` 将一个字符串表示一个 `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()` 将这一 `byte` `BigDecimal`，检查丢失的信息。
`int`	`compareTo(BigDecimal val)` 这 `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`商 `(this / divisor)`整数部分向下舍入。
`BigDecimal`	`divideToIntegralValue(BigDecimal divisor, MathContext mc)` 返回的值是 `BigDecimal` `(this / divisor)`整数部分。
`double`	`doubleValue()` 将这一 `double` `BigDecimal`。
`boolean`	`equals(Object x)` 这 `BigDecimal`与平等的规定 `Object`比较。
`float`	`floatValue()` 将这一 `float` `BigDecimal`。
`int`	`hashCode()` 返回此 `BigDecimal`哈希代码。
`int`	`intValue()` 将这一 `int` `BigDecimal`。
`int`	`intValueExact()` 将这一 `int` `BigDecimal`，检查丢失的信息。
`long`	`longValue()` 将这一 `long` `BigDecimal`。
`long`	`longValueExact()` 将这一 `long` `BigDecimal`，检查丢失的信息。
`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)` 返回的值是 `(thisⁿ)` `BigDecimal`。
`int`	`precision()` 返回该 `BigDecimal`的精度。
`BigDecimal`	`remainder(BigDecimal divisor)` 返回的值是 `(this % divisor)` `BigDecimal`。
`BigDecimal`	`remainder(BigDecimal divisor, MathContext mc)` 返回的值是 `BigDecimal` `(this % divisor)`，舍入根据语境的设置。
`BigDecimal`	`round(MathContext mc)` 返回一个 `BigDecimal`圆形根据 `MathContext`设置。
`int`	`scale()` 返回该 `BigDecimal`的规模。
`BigDecimal`	`scaleByPowerOfTen(int n)` 返回来的值等于（ `this`×10 ⁿ）。
`BigDecimal`	`setScale(int newScale)` 返回一个 `BigDecimal`其规模是指定的值，其值是数值等于该 `BigDecimal`的。
`BigDecimal`	`setScale(int newScale, int roundingMode)` 返回一个 `BigDecimal`其规模是规定值，且不成比例的价值乘以或除以 `BigDecimal`的缩放值十的合适的电源来维持其整体价值的确定。
`BigDecimal`	`setScale(int newScale, RoundingMode roundingMode)` 返回一个 `BigDecimal`其规模是规定值，且不成比例的价值乘以或除以 `BigDecimal`的缩放值十的合适的电源来维持其整体价值的确定。
`short`	`shortValueExact()` 将这一 `short` `BigDecimal`，检查丢失的信息。
`int`	`signum()` 返回该 `BigDecimal` signum函数。
`BigDecimal`	`stripTrailingZeros()` 返回一个 `BigDecimal`，数值上等于这一但任何尾随零从表示删除。
`BigDecimal`	`subtract(BigDecimal subtrahend)` 返回的值是 `BigDecimal` `(this - subtrahend)`，其规模 `max(this.scale(), subtrahend.scale())`。
`BigDecimal`	`subtract(BigDecimal subtrahend, MathContext mc)` 返回的值是 `BigDecimal` `(this - subtrahend)`，舍入根据语境的设置。
`BigInteger`	`toBigInteger()` 将这一 `BigInteger` `BigDecimal`。
`BigInteger`	`toBigIntegerExact()` 将这一 `BigInteger` `BigDecimal`，检查丢失的信息。
`String`	`toEngineeringString()` 这 `BigDecimal`返回字符串表示，如果指数是需要使用工程符号。
`String`	`toPlainString()` 返回一个没有指数域这 `BigDecimal`字符串表示形式。
`String`	`toString()` 返回该 `BigDecimal`字符串表示，如果指数是需要使用科学记数法。
`BigDecimal`	`ulp()` 返回一个小的尺寸，最后一个单元，这 `BigDecimal`。
`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

- Field Detail
  - ZERO
```
public static final BigDecimal ZERO
```
    值为0，规模为0。
    
    从以下版本开始：
    
    一点五
  - ONE
```
public static final BigDecimal ONE
```
    值为1，规模为0。
    
    从以下版本开始：
    
    一点五
  - TEN
```
public static final BigDecimal TEN
```
    值为10，规模为0。
    
    从以下版本开始：
    
    一点五
  - 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
- Constructor Detail
  - BigDecimal
```
public BigDecimal(char[] in,
                  int offset,
                  int len)
```
    翻译一 BigDecimal字符数组表示为 BigDecimal，接受相同的字符序列的 BigDecimal(String)构造函数，同时允许子阵列中被指定。
    注意，如果该字符序列已经可以在字符数组，使用此构造函数比转换char数组，字符串和使用BigDecimal(String)构造函数更快。
    
    参数
    
    in - char阵列，字源。
    
    offset -第一个字符数组中的检查。
    
    len -字符数的考虑。
    
    异常
    
    NumberFormatException -如果 in不是一个 BigDecimal或定义的子阵的有效表示并不完全是在 in。
    
    从以下版本开始：
    
    一点五
  - BigDecimal
```
public BigDecimal(char[] in,
                  int offset,
                  int len,
                  MathContext mc)
```
    翻译一 BigDecimal字符数组表示为 BigDecimal，接受相同的字符序列的 BigDecimal(String)构造函数，同时允许子阵被指定和舍入根据语境的设置。
    注意，如果该字符序列已经可以在字符数组，使用此构造函数比转换char数组，字符串和使用BigDecimal(String)构造函数更快。
    
    参数
    
    in -这是字源 char阵列。
    
    offset -第一个字符数组中的检查。
    
    len -字符数考虑..
    
    mc的情况下使用。
    
    异常
    
    ArithmeticException -如果结果不精确但舍入模式 UNNECESSARY。
    
    NumberFormatException -如果 in不是一个 BigDecimal或定义的子阵的有效表示并不完全是在 in。
    
    从以下版本开始：
    
    一点五
  - BigDecimal
```
public BigDecimal(char[] in)
```
    翻译一 BigDecimal字符数组表示为 BigDecimal，接受相同的字符序列的 BigDecimal(String)构造函数。
    注意，如果该字符序列已经可以作为一个字符数组，使用此构造函数比转换char数组，字符串和使用BigDecimal(String)构造函数更快。
    
    参数
    
    in -这是字源 char阵列。
    
    异常
    
    NumberFormatException -如果 in不是一个 BigDecimal合法表示。
    
    从以下版本开始：
    
    一点五
  - BigDecimal
```
public BigDecimal(char[] in,
                  MathContext mc)
```
    翻译一 BigDecimal字符数组表示为 BigDecimal，接受相同的字符序列的 BigDecimal(String)构造函数和舍入根据语境的设置。
    注意，如果该字符序列已经可以作为一个字符数组，使用此构造函数比转换char数组，字符串和使用BigDecimal(String)构造函数更快。
    
    参数
    
    in -这是字源 char阵列。
    
    mc的情况下使用。
    
    异常
    
    ArithmeticException -如果结果不精确但舍入模式 UNNECESSARY。
    
    NumberFormatException -如果 in不是一个 BigDecimal合法表示。
    
    从以下版本开始：
    
    一点五
  - 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:
    
    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”[ 2 ]“123”[ 123,0 ]“123”[ 123,0 ]“1.23e3”[ 123，1 ]“1.23e + 3”[ 123，1 ]“12.3e + 7”[ 123，6 ]“12”[ 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 ]
```
    注：除float和double南和±无穷大值，此构造函数与价值兼容的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的情况下使用。
    
    异常
    
    ArithmeticException -如果结果不精确但舍入模式 UNNECESSARY。
    
    如果不是 NumberFormatException val BigDecimal的有效表达。
    
    从以下版本开始：
    
    一点五
  - BigDecimal
```
public BigDecimal(double val)
```
    翻译成 BigDecimal double的 double二进制浮点值的小数表示。返回的 BigDecimal规模最小的值是一个整数， (10^scale × val)。
    笔记:
    1. 这个构造函数的结果可以是有点不可预测的。有人可能会认为写作new BigDecimal(0.1)在java创建一个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无限或南。
  - BigDecimal
```
public BigDecimal(double val,
                  MathContext mc)
```
    翻译 double成 BigDecimal，舍入根据语境的设置。该 BigDecimal规模最小的值是一个整数， (10^scale × val)。
    这个构造函数的结果有一定的不可预知性，一般不建议使用；看到BigDecimal(double)构造函数笔记下。
    
    参数
    
    val - double值被转换为 BigDecimal。
    
    mc的情况下使用。
    
    异常
    
    ArithmeticException -如果结果不精确但roundingmode是不必要的。
    
    NumberFormatException -如果 val无限或南。
    
    从以下版本开始：
    
    一点五
  - 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 -如果结果不精确但舍入模式 UNNECESSARY。
    
    从以下版本开始：
    
    一点五
  - 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的情况下使用。
    
    异常
    
    ArithmeticException -如果结果不精确但舍入模式 UNNECESSARY。
    
    从以下版本开始：
    
    一点五
  - BigDecimal
```
public BigDecimal(int val)
```
    翻译成 BigDecimal int。该 BigDecimal规模为零。
    
    参数
    
    val - int值被转换为 BigDecimal。
    
    从以下版本开始：
    
    一点五
  - BigDecimal
```
public BigDecimal(int val,
                  MathContext mc)
```
    翻译 int成 BigDecimal，舍入根据语境的设置。该 BigDecimal规模，之前的任何舍入为零。
    
    参数
    
    val - int值被转换为 BigDecimal。
    
    mc的情况下使用。
    
    异常
    
    ArithmeticException -如果结果不精确但舍入模式 UNNECESSARY。
    
    从以下版本开始：
    
    一点五
  - BigDecimal
```
public BigDecimal(long val)
```
    翻译成 BigDecimal long。该 BigDecimal规模为零。
    
    参数
    
    val - long值被转换为 BigDecimal。
    
    从以下版本开始：
    
    一点五
  - BigDecimal
```
public BigDecimal(long val,
                  MathContext mc)
```
    翻译 long成 BigDecimal，舍入根据语境的设置。该 BigDecimal规模，之前的任何舍入为零。
    
    参数
    
    val - long值被转换为 BigDecimal。
    
    mc的情况下使用。
    
    异常
    
    ArithmeticException -如果结果不精确但舍入模式 UNNECESSARY。
    
    从以下版本开始：
    
    一点五
- 方法详细信息
  - 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，作为返回值等于从使用Double.toString(double)结果构建BigDecimal造成。
    
    参数
    
    val - double转换为 BigDecimal。
    
    结果
    
    一个 BigDecimal其值等于或约等于 val价值。
    
    异常
    
    NumberFormatException -如果 val无限或南。
    
    从以下版本开始：
    
    一点五
  - 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 -如果结果不精确但舍入模式 UNNECESSARY。
    
    从以下版本开始：
    
    一点五
  - 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，圆形是必要的。
    
    异常
    
    ArithmeticException -如果结果不精确但舍入模式 UNNECESSARY。
    
    从以下版本开始：
    
    一点五
  - 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，圆形是必要的。
    
    异常
    
    ArithmeticException -如果结果不精确但舍入模式 UNNECESSARY。
    
    从以下版本开始：
    
    一点五
  - 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和指定的规模不足表示相除的结果准确。
    
    从以下版本开始：
    
    一点五
  - 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()不足表示相除的结果准确。
    
    从以下版本开始：
    
    一点五
  - divide
```
public BigDecimal divide(BigDecimal divisor)
```
    返回的值是 BigDecimal (this / divisor)，和其首选的规模 (this.scale() - divisor.scale())；如果准确的商不能代表（因为它有一个十进制小数点扩展）的 ArithmeticException抛出。
    
    参数
    
    divisor值，这 BigDecimal是分。
    
    结果
    
    this / divisor
    
    异常
    
    ArithmeticException如果准确的商没有终止的十进制扩展
    
    从以下版本开始：
    
    一点五
  - divide
```
public BigDecimal divide(BigDecimal divisor,
                         MathContext mc)
```
    返回的值是 BigDecimal (this / divisor)，舍入根据语境的设置。
    
    参数
    
    divisor值，这 BigDecimal是分。
    
    mc的情况下使用。
    
    结果
    
    this / divisor，圆形是必要的。
    
    异常
    
    ArithmeticException -如果结果不精确但舍入模式 UNNECESSARY或 mc.precision == 0和商有一个十进制小数点扩张。
    
    从以下版本开始：
    
    一点五
  - divideToIntegralValue
```
public BigDecimal divideToIntegralValue(BigDecimal divisor)
```
    返回的值是 BigDecimal商 (this / divisor)整数部分向下舍入。结果优选的规模 (this.scale() - divisor.scale())。
    
    参数
    
    divisor值，这 BigDecimal是分。
    
    结果
    
    this / divisor的整数部分。
    
    异常
    
    如果 divisor==0 ArithmeticException
    
    从以下版本开始：
    
    一点五
  - divideToIntegralValue
```
public BigDecimal divideToIntegralValue(BigDecimal divisor,
                                        MathContext mc)
```
    返回的值是 BigDecimal (this / divisor)整数部分。由于确切的商的整数部分不依赖于四舍五入模式，四舍五入模式不影响由该方法返回的值。结果优选的规模 (this.scale() - divisor.scale())。一个 ArithmeticException如果准确的商的整数部分的需求超过 mc.precision数字扔。
    
    参数
    
    divisor值，这 BigDecimal是分。
    
    mc的情况下使用。
    
    结果
    
    this / divisor的整数部分。
    
    异常
    
    如果 divisor==0 ArithmeticException
    
    ArithmeticException -如果 mc.precision > 0，结果需要一个以上的精度 mc.precision位数。
    
    从以下版本开始：
    
    一点五
  - remainder
```
public BigDecimal remainder(BigDecimal divisor)
```
    返回的值是 (this % divisor) BigDecimal。
    其余的是由this.subtract(this.divideToIntegralValue(divisor).multiply(divisor))。请注意，这不是取模运算（结果可能是负面的）。
    
    参数
    
    divisor值，这 BigDecimal是分。
    
    结果
    
    this % divisor。
    
    异常
    
    如果 divisor==0 ArithmeticException
    
    从以下版本开始：
    
    一点五
  - 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，圆形是必要的。
    
    异常
    
    如果 divisor==0 ArithmeticException
    
    ArithmeticException -如果结果不精确但舍入模式 UNNECESSARY，或 mc.precision > 0， this.divideToIntgralValue(divisor)结果需要一个以上的精度 mc.precision位数。
    
    从以下版本开始：
    
    一点五
    
    另请参见：
    
    divideToIntegralValue(java.math.BigDecimal, java.math.MathContext)
  - divideAndRemainder
```
public BigDecimal[] divideAndRemainder(BigDecimal divisor)
```
    返回一二元 BigDecimal数组包含的结果 divideToIntegralValue随后对两个操作数 remainder结果。
    注意，如果两个整数的商和余数是必要的，这种方法比使用divideToIntegralValue和remainder方法分别因为师只需要进行一次。
    
    参数
    
    divisor值，这 BigDecimal是可分的，而其余的计算。
    
    结果
    
    一二元 BigDecimal阵列：商（的 divideToIntegralValue结果）是最初的元素，其余的是最后一个元素。
    
    异常
    
    如果 divisor==0 ArithmeticException
    
    从以下版本开始：
    
    一点五
    
    另请参见：
    
    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和remainder方法分别因为师只需要进行一次。
    
    参数
    
    divisor值，这 BigDecimal是可分的，而其余的计算。
    
    mc的情况下使用。
    
    结果
    
    一二元 BigDecimal阵列：商（的 divideToIntegralValue结果）是最初的元素，其余的是最后一个元素。
    
    异常
    
    如果 divisor==0 ArithmeticException
    
    ArithmeticException -如果结果不精确但舍入模式 UNNECESSARY，或 mc.precision > 0， this.divideToIntgralValue(divisor)结果需要一个以上的精度 mc.precision位数。
    
    从以下版本开始：
    
    一点五
    
    另请参见：
    
    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超出范围。
    
    从以下版本开始：
    
    一点五
  - pow
```
public BigDecimal pow(int n,
                      MathContext mc)
```
    返回的值是 (thisⁿ) BigDecimal。目前的实现使用ANSI标准定义的x3.274-1996舍入根据上下文设置的核心算法。在一般情况下，返回的值是在所选择的精度进行精确数值的两。请注意，未来的版本可能会使用不同的算法，减少了允许误差界和增加了允许的指数范围。
    的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，或 n超出范围。
    
    从以下版本开始：
    
    一点五
  - abs
```
public BigDecimal abs()
```
    返回一个 BigDecimal其价值是本 BigDecimal的绝对值，其规模 this.scale()。
    
    结果
    
    abs(this)
  - abs
```
public BigDecimal abs(MathContext mc)
```
    返回一个 BigDecimal其价值是本 BigDecimal绝对值舍入根据语境设置。
    
    参数
    
    mc的情况下使用。
    
    结果
    
    abs(this)，圆形是必要的。
    
    异常
    
    ArithmeticException -如果结果不精确但舍入模式 UNNECESSARY。
    
    从以下版本开始：
    
    一点五
  - negate
```
public BigDecimal negate()
```
    返回的值是 BigDecimal (-this)，其规模 this.scale()。
    
    结果
    
    -this。
  - negate
```
public BigDecimal negate(MathContext mc)
```
    返回的值是 BigDecimal (-this)，舍入根据语境的设置。
    
    参数
    
    mc的情况下使用。
    
    结果
    
    -this，圆形是必要的。
    
    异常
    
    ArithmeticException -如果结果不精确但舍入模式 UNNECESSARY。
    
    从以下版本开始：
    
    一点五
  - plus
```
public BigDecimal plus()
```
    返回的值是 BigDecimal (+this)，其规模 this.scale()。
    这种方法只是返回这个BigDecimal包括对称与一元减号的方法negate()。
    
    结果
    
    this。
    
    从以下版本开始：
    
    一点五
    
    另请参见：
    
    negate()
  - plus
```
public BigDecimal plus(MathContext mc)
```
    返回的值是 BigDecimal (+this)，舍入根据语境的设置。
    这种方法的效果是相同的round(MathContext)方法。
    
    参数
    
    mc的情况下使用。
    
    结果
    
    this，圆形是必要的。一零的结果将有一个规模为0。
    
    异常
    
    ArithmeticException -如果结果不精确但舍入模式 UNNECESSARY。
    
    从以下版本开始：
    
    一点五
    
    另请参见：
    
    round(MathContext)
  - signum
```
public int signum()
```
    返回该 BigDecimal signum函数。
    
    结果
    
    1，0，或1本 BigDecimal值为负，零或正。
  - scale
```
public int scale()
```
    返回该 BigDecimal的规模。如果零或正，规模是小数点右边的数字的位数。如果负的数量不成比例的值乘以十规模的否定的力量。例如，一个规模 -3意味着不成比例的值乘以1000。
    
    结果
    
    这 BigDecimal规模。
  - precision
```
public int precision()
```
    返回该 BigDecimal的精度。（精度在不成比例的价值。位数）
    1值的精度为一零。
    
    结果
    
    这 BigDecimal精度。
    
    从以下版本开始：
    
    一点五
  - unscaledValue
```
public BigInteger unscaledValue()
```
    返回一个 BigInteger其价值是本 BigDecimal的不成比例的价值。（计算 (this * 10^this.scale())。）
    
    结果
    
    这 BigDecimal不成比例的价值。
    
    从以下版本开始：
    
    一点二
  - round
```
public BigDecimal round(MathContext mc)
```
    返回一个 BigDecimal圆形根据 MathContext设置。如果精度设置为0，则不发生四舍五入。
    这种方法的效果是相同的plus(MathContext)方法。
    
    参数
    
    mc的情况下使用。
    
    结果
    
    一个 BigDecimal圆形根据 MathContext设置。
    
    异常
    
    ArithmeticException如果舍入模式 UNNECESSARY和 BigDecimal操作需要舍入。
    
    从以下版本开始：
    
    一点五
    
    另请参见：
    
    plus(MathContext)
  - setScale
```
public BigDecimal setScale(int newScale,
                           RoundingMode roundingMode)
```
    返回一个 BigDecimal其规模是规定值，且不成比例的价值乘以或除以 BigDecimal的缩放值十的合适的电源来维持其整体价值的确定。若按操作减少，不成比例的值必须是可分的（而不是增加），和值可能会发生变化；在这种情况下，指定的舍入模式应用于分。
    请注意，由于BigDecimal对象是不可变的，这种方法要求在原对象的修改做不结果，相反有方法命名为setX变异场相反的惯例，setScale返回与适度规模的目标；返回的对象可能会或可能不会被重新分配。
    
    参数
    
    newScale的 BigDecimal值返回。
    
    roundingMode的舍入模式适用。
    
    结果
    
    一个 BigDecimal其规模是规定值，且不成比例的价值乘以或除以 BigDecimal的缩放值十的合适的电源来维持其整体价值的确定。
    
    异常
    
    ArithmeticException -如果 roundingMode==UNNECESSARY和指定的缩放操作需要舍入。
    
    从以下版本开始：
    
    一点五
    
    另请参见：
    
    RoundingMode
  - setScale
```
public BigDecimal setScale(int newScale,
                           int roundingMode)
```
    返回一个 BigDecimal其规模是规定值，且不成比例的价值乘以或除以 BigDecimal的缩放值十的合适的电源来维持其整体价值的确定。若按操作减少，不成比例的值必须是可分的（而不是增加），和值可能会发生变化；在这种情况下，指定的舍入模式应用于分。
    请注意，由于BigDecimal对象是不可变的，这种方法要求在原对象的修改做不结果，相反有方法命名为setX变异场相反的惯例，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
  - setScale
```
public BigDecimal setScale(int newScale)
```
    返回一个 BigDecimal其规模是指定的值，其值是数值等于该 BigDecimal，抛出一个 ArithmeticException如果这是不可能的。
    这个电话通常是用来增加规模，在这种情况下，这是保证存在一个BigDecimal指定的尺度和正确的价值。电话也可以用来当调用者知道BigDecimal在其小数部分的一端有足够多的零点降低规模（即，十因素在其整数）允许的调整没有改变它的值。
    
    该方法将返回相同的结果作为setScale两参数的版本，但节省了调用的情况下是不相关的指定舍入模式的麻烦。
    
    值得注意的是，由于BigDecimal对象是不可变的，这种方法要求在原对象的修改做不结果，相反有方法命名为setX变异场相反的惯例，setScale返回与适度规模的目标；返回的对象可能会或可能不会被重新分配。
    
    参数
    
    newScale的 BigDecimal值返回。
    
    结果
    
    一个 BigDecimal其规模是规定值，且不成比例的价值乘以或除以 BigDecimal的缩放值十的合适的电源来维持其整体价值的确定。
    
    异常
    
    ArithmeticException -如果指定的缩放操作需要舍入。
    
    另请参见：
    
    setScale(int, int)， setScale(int, RoundingMode)
  - movePointLeft
```
public BigDecimal movePointLeft(int n)
```
    返回一个 BigDecimal相当于一个与小数点移动 n地方留下。如果 n是非负的，电话只是增加了 n的规模。如果 n是负的，相当于 movePointRight(-n)呼叫。的 BigDecimal此调用所返回的值 (this × 10^-n)和规模 max(this.scale()+n, 0)。
    
    参数
    
    n -地方移动小数点左边的数字。
    
    结果
    
    一个 BigDecimal相当于一个与小数点移动 n地方留下。
    
    异常
    
    ArithmeticException如果规模溢出。
  - movePointRight
```
public BigDecimal movePointRight(int n)
```
    返回一个 BigDecimal相当于这一 n小数点移动到正确的地方。如果 n是非负的，电话只是减去 n从规模。如果 n是负的，相当于 movePointLeft(-n)呼叫。的 BigDecimal此调用所返回的值 (this × 10ⁿ)和规模 max(this.scale()-n, 0)。
    
    参数
    
    n -地方移动小数点右边的数。
    
    结果
    
    一个 BigDecimal相当于这一 n小数点移动到正确的地方。
    
    异常
    
    ArithmeticException如果规模溢出。
  - scaleByPowerOfTen
```
public BigDecimal scaleByPowerOfTen(int n)
```
    返回来的值等于（ this×10 ⁿ）。结果的规模 (this.scale() - n)。
    
    参数
    
    n -十规模的幂
    
    结果
    
    一个BigDecimal的数值等于（ this×10 ⁿ）
    
    异常
    
    ArithmeticException -如果规模将在一个32位的整数范围。
    
    从以下版本开始：
    
    一点五
  - stripTrailingZeros
```
public BigDecimal stripTrailingZeros()
```
    返回一个 BigDecimal，数值上等于这一但任何尾随零从表示删除。例如，从 BigDecimal价值 600.0剥离尾随零，具有[ BigInteger， scale ]成分等于[ 6000，1 ]，以[ BigInteger产量 6E2， scale ]成分等于[ 6，2 ]。如果BigDecimal的数值等于零，然后 BigDecimal.ZERO返回。
    
    结果
    
    与任何尾随零删除数值等于 BigDecimal。
    
    从以下版本开始：
    
    一点五
  - compareTo
```
public int compareTo(BigDecimal val)
```
    这 BigDecimal与指定的 BigDecimal比较。两 BigDecimal对象是平等的价值，但有不同的尺度（如2和2）被视为相等的方法。此方法提供了对六个布尔比较运算符（<，= = = = = =的”的每个方法的单独方法的偏好性，！=，< =）。建议的成语进行比较： (x.compareTo(y) < > 0) OP，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不等于2时相比，用这种方法）。
    
    重写：
    
    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大。如果他们是平等的，由 compareTo方法定义， this返回。
    
    另请参见：
    
    compareTo(java.math.BigDecimal)
  - hashCode
```
public int hashCode()
```
    返回此 BigDecimal哈希代码。值得注意的是，两 BigDecimal对象相等但不同尺度（如2和2）一般会不具有相同的哈希代码。
    
    重写：
    
    hashCode 方法重写，继承类 Object
    
    结果
    
    这 BigDecimal哈希代码。
    
    另请参见：
    
    equals(Object)
  - 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使用BigDecimal(String)构造函数，然后原来的值将被收回。
    2. 对于一个给定的数字所产生的字符串总是相同的，它不受语言环境的影响。这意味着它可以被用来作为交换的十进制数据规范的字符串表示形式，或作为一个哈希表的键，等现场敏感号码格式化和分析是由NumberFormat类及其子类处理。
    3. 的toEngineeringString()方法可用于展示数字与工程符号指数，和setScale方法可用于BigDecimal所以舍去小数点后的位数有一个已知的。
    4. 数字字符映射Character.forDigit提供的应用。
    重写：
    
    toString 方法重写，继承类 Object
    
    结果
    
    这 BigDecimal字符串表示形式。
    
    另请参见：
    
    Character.forDigit(int, int)， BigDecimal(java.lang.String)
  - toEngineeringString
```
public String toEngineeringString()
```
    这 BigDecimal返回字符串表示，如果指数是需要使用工程符号。
    返回一个字符串，表示BigDecimal在toString()方法的描述，但如果指数符号的使用，十的功率调整为三的倍数（工程符号）这样的非零值的整数部分将在范围1到999。如果使用指数符号为0值，则使用一个小数点和一个或两个分数零位，使零值的刻度保持。值得注意的是，不同于toString()输出，该方法的输出是不能保证收回同样的[整数，如果输出字符串转换回一个BigDecimal使用string constructor这BigDecimal规模]对。这种方法的结果满足弱约束总是使用字符串构造函数方法的输出产生一个数值相等的结果。
    
    结果
    
    这 BigDecimal字符串表示，如果指数是需要使用工程符号。
    
    从以下版本开始：
    
    一点五
  - toPlainString
```
public String toPlainString()
```
    返回一个没有指数域这 BigDecimal字符串表示形式。对于一个正比例的值，小数点右边的数字的位数是用来表示刻度的。对于具有一零个或负尺度的值，产生的字符串，如果值被转换为一个数值等于零的规模和，如果所有的零规模的值的尾随零的结果。整个字符串将以减号作为前缀字符“-”（ '\u002D'）如果不成比例的值小于零。无符号字符的前缀如果不成比例的价值为零或正。注意，如果该方法的结果传递给 string constructor，只有这个 BigDecimal数值必然会恢复；对新 BigDecimal表示可能有不同的尺度。特别是，如果这 BigDecimal具有负的规模，通过这种方法得到的字符串将有零规模时处理的字符串的构造函数。（此方法的行为类似于1.4 toString方法和更早的版本。）
    
    结果
    
    一个没有指数域这 BigDecimal字符串表示形式。
    
    从以下版本开始：
    
    一点五
    
    另请参见：
    
    toString()， toEngineeringString()
  - toBigInteger
```
public BigInteger toBigInteger()
```
    将这一 BigInteger BigDecimal。这种转换是类似于缩小基本转换从 double到 long在 The Java™ Language Specification第定义：本 BigDecimal任何小数部分将被丢弃。请注意，这种转换可以失去的 BigDecimal值的精度信息。
    有一个例外，如果转换不精确抛（换句话说，如果一个非零的小数部分被丢弃），使用toBigIntegerExact()方法。
    
    结果
    
    这 BigDecimal转换为 BigInteger。
  - toBigIntegerExact
```
public BigInteger toBigIntegerExact()
```
    将这一 BigInteger BigDecimal，检查丢失的信息。如果这 BigDecimal具有非零的小数部分抛异常。
    
    结果
    
    这 BigDecimal转换为 BigInteger。
    
    异常
    
    ArithmeticException this -如果有一个非零的小数部分。
    
    从以下版本开始：
    
    一点五
  - longValue
```
public long longValue()
```
    将这一 long BigDecimal。这种转换是类似于缩小基本转换从 double到 short在 The Java™ Language Specification第定义：本 BigDecimal任何小数部分将被丢弃，如果产生的“ BigInteger”太大，适合在一个 long，只返回低阶64位。请注意，这种转换也能返回一个具有相反的符号结果失去这 BigDecimal值总体大小和精度信息。
    
    Specified by:
    
    longValue 方法重写，继承类 Number
    
    结果
    
    这 BigDecimal转换为 long。
  - longValueExact
```
public long longValueExact()
```
    将这一 long BigDecimal，检查丢失的信息。如果这 BigDecimal具有非零的小数部分或不可能的范围内，一个 long结果然后 ArithmeticException抛出。
    
    结果
    
    这 BigDecimal转换为 long。
    
    异常
    
    ArithmeticException this -如果有一个非零的小数部分，或不适合在 long。
    
    从以下版本开始：
    
    一点五
  - intValue
```
public int intValue()
```
    将这一 int BigDecimal。这种转换是类似于缩小基本转换从 double到 short在 The Java™ Language Specification第定义：本 BigDecimal任何小数部分将被丢弃，如果产生的“ BigInteger”太大，装在一个 int，只返回低阶32位。请注意，这种转换也能返回一个具有相反的符号结果失去这 BigDecimal值总体大小和精度信息。
    
    Specified by:
    
    intValue 方法重写，继承类 Number
    
    结果
    
    这 BigDecimal转换为 int。
  - intValueExact
```
public int intValueExact()
```
    将这一 int BigDecimal，检查丢失的信息。如果这 BigDecimal具有非零的小数部分或不可能的范围内，一个 int结果然后 ArithmeticException抛出。
    
    结果
    
    这 BigDecimal转换为 int。
    
    异常
    
    ArithmeticException this -如果有一个非零的小数部分，或不适合在 int。
    
    从以下版本开始：
    
    一点五
  - shortValueExact
```
public short shortValueExact()
```
    将这一 short BigDecimal，检查丢失的信息。如果这 BigDecimal具有非零的小数部分或不可能的范围内，一个 short结果然后 ArithmeticException抛出。
    
    结果
    
    这 BigDecimal转换为 short。
    
    异常
    
    ArithmeticException this -如果有一个非零的小数部分，或不适合在 short。
    
    从以下版本开始：
    
    一点五
  - byteValueExact
```
public byte byteValueExact()
```
    将这一 byte BigDecimal，检查丢失的信息。如果这 BigDecimal具有非零的小数部分或不可能的范围内，一个 byte结果然后 ArithmeticException抛出。
    
    结果
    
    这 BigDecimal转换为 byte。
    
    异常
    
    ArithmeticException this -如果有一个非零的小数部分，或不适合在 byte。
    
    从以下版本开始：
    
    一点五
  - floatValue
```
public float floatValue()
```
    将这一 float BigDecimal。这种转换是类似的缩小基本转换从 double到 float在 The Java™ Language Specification第定义：如果这 BigDecimal有太大的值代表一个 float，它将被转换为 Float.NEGATIVE_INFINITY或 Float.POSITIVE_INFINITY适当。请注意，即使当返回值是有限的，这种转换可以失去的 BigDecimal值的精度信息。
    
    Specified by:
    
    floatValue 方法重写，继承类 Number
    
    结果
    
    这 BigDecimal转换为 float。
  - doubleValue
```
public double doubleValue()
```
    将这一 double BigDecimal。这种转换是类似的缩小基本转换从 double到 float在 The Java™ Language Specification第定义：如果这 BigDecimal有太大的幅度代表作为一个 double，它将被转换为 Double.NEGATIVE_INFINITY或 Double.POSITIVE_INFINITY适当。请注意，即使当返回值是有限的，这种转换可以失去的 BigDecimal值的精度信息。
    
    Specified by:
    
    doubleValue 方法重写，继承类 Number
    
    结果
    
    这 BigDecimal转换为 double。
  - ulp
```
public BigDecimal ulp()
```
    返回一个小的尺寸，最后一个单元，这 BigDecimal。一个非零的值 BigDecimal ULP这是价值和价值 BigDecimal下较大的幅度与相同的位数之间的正距离。一零价值的ULP的数值等于1的 this规模。结果存储规模 this一样，零和非零的值，结果等于 [1, this.scale()]。
    
    结果
    
    一个小规模的 this
    
    从以下版本开始：
    
    一点五

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

Field Detail

ZERO

ONE

TEN

ROUND_UP

ROUND_DOWN

ROUND_CEILING

ROUND_FLOOR

ROUND_HALF_UP

ROUND_HALF_DOWN

ROUND_HALF_EVEN

ROUND_UNNECESSARY

Constructor Detail

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