BigDecimal (Java 2 Platform SE 6)

概觀

軟體套件

類別

使用

階層樹

已過時

索引

說明

Java^TM 2 Platform
Standard Ed. 6

上一個類別 下一個類別

框架 無框架

摘要：巢狀 | 欄位 | 建構子 | 方法

詳細資訊：欄位 | 建構子 | 方法

java.math
類別 BigDecimal

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

所有已實作的介面：: Serializable, Comparable<BigDecimal>

public class BigDecimal
extends Number
implements Comparable<BigDecimal>
extends Number
implements Comparable<BigDecimal>

不可變的、任意精度的有符號十進制數。BigDecimal 由任意精度的整數非標度值 和 32 位的整數標度 (scale) 組成。如果為零或正數，則標度是小數點後的位數。如果為負數，則將該數的非標度值乘以 10 的負 scale 次方。因此，BigDecimal 表示的數值是 (unscaledValue × 10^-scale)。

BigDecimal 類別提供以下操作：算術、標度操作、捨入、比較、雜湊演算法和格式轉換。toString() 方法提供 BigDecimal 的規範表示形式。

BigDecimal 類別使使用者能完全控制捨入行為。如果未指定捨入網要，並且無法表示準確結果，則拋出一個異常；否則，通過向該操作提供適當的 MathContext 物件，可以對已選擇的精度和捨入網要執行計算。在任何情況下，可以為捨入控制提供八種捨入網要。使用此類別（例如，ROUND_HALF_UP）中的整數欄位來表示捨入網要已過時；應改為使用 RoundingMode enum（例如，RoundingMode.HALF_UP）的列舉值。

當為 MathContext 物件提供 0 的精度設置（例如，MathContext.UNLIMITED）時，算術運算是準確的，它們是不採用任何 MathContext 物件的算術方法。（這是第 5 版之前的版本支持的唯一行為。）為了計算準確結果，不使用附帶 0 精度設置的 MathContext 物件的捨入網要設置，因此與該物件無關。在除法中，準確的商可能是一個無限長的十進制擴展；例如，1 除以 3 所得的商。如果商具有無窮的十進制擴展，但是指定了該操作返回準確結果，則拋出 ArithmeticException。否則，像其他操作那樣，返回除法運算的準確結果。

當精度設置不為 0 時，BigDecimal 演算法的規則完全符合 ANSI X3.274-1996 和 ANSI X3.274-1996/AM 1-2000（ 7.4 節）中定義的演算法的可選操作網要。與上述標準不同，BigDecimal 套件括多種捨入網要，它們對於版本 5 以前的 BigDecimal 版本中的除法是強制性的。這些 ANSI 標準和 BigDecimal 規範之間的任何衝突都按照有利於 BigDecimal 的方式進行解決。

由於同一數值可以有不同的表示形式（具有不同的標度），因此運算和捨入的規則必須同時指定數值結果和結果表示形式中所用的標度。

一般情況下，當準確結果（在除法中，可能有無限多位）比返回的數值具有更多位數時，捨入網要和精度設置確定操作如何返回具有有限位數的結果。首先，MathContext 的 precision 設置指定要返回的總位數；這確定了結果的精度。位數計數從準確結果的最左邊的非零數字開始。捨入網要確定丟棄的尾部位數如何影響返回的結果。

對於所有算術運算符，運算的執行方式是，首先計算準確的中間結果，然後，使用選擇的捨入網要將其捨入為精度設置（如有必要）指定的位數。如果不返回準確結果，則將丟棄準確結果的某些數位。當捨入增加了返回結果的大小時，前導數字“9”的進位傳播可能會創建新的數位。例如，將值 999.9 捨入為三位數字，則在數值上等於一千，表示為 100×10¹。在這種情況下，新的 "1" 是返回結果的前導數位。

除了邏輯的準確結果外，每種算術運算都有一個表示結果的首選標度。下表列出了每個運算的首選標度。

算術運算結果的首選標度
運算	結果的首選標度
加	max(addend.scale(), augend.scale())
減	max(minuend.scale(), subtrahend.scale())
乘	multiplier.scale() + multiplicand.scale()
除	dividend.scale() - divisor.scale()

這些標度是返回準確算術結果的方法使用的標度；準確相除可能必須使用較大的標度除外，因為準確的結果可能有較多的位數。例如，1/32 得到 0.03125。

捨入之前，邏輯的準確中間結果的標度是該運算的首選標度。如果用 precision 位數無法表示準確的數值結果，則捨入會選擇要返回的一組數字，並將該結果的標度從中間結果的標度減小到可以表示實際返回的 precision 位數的最小標度。如果準確結果可以使用最多 precision 個數字表示，則返回具有最接近首選標度的標度的結果表示形式。尤其是，通過移除結尾零並減少標度，可以用少於 precision 個數字來表示準確的可表示的商。例如，使用 floor 捨入網要將結果捨入為三個數字，
19/100 = 0.19 // integer=19, scale=2
但是
21/110 = 0.190 // integer=190, scale=3

注意，對於加、減和乘，標度的縮減量將等於丟棄的準確結果的數字位置數。如果捨入導致進位傳播創建一個新的高位，則當未創建新的數位時，會丟棄該結果的附加數字。

其他方法可能與捨入語義稍微不同。例如，使用指定的演算法的 pow 方法得到的結果可能偶爾不同於捨入得到的算術結果，如最後一位有多個單位（ulp）。

可以通過兩種型別的操作來處理 BigDecimal 的標度：標度/捨入操作和小數點移動操作。標度/捨入操作（setScale 和 round）返回 BigDecimal，其值近似地（或精確地）等於操作數的值，但是其標度或精度是指定的值；即：它們會增加或減少對其值具有最小影響的存儲數的精度。小數點移動操作（movePointLeft 和 movePointRight）返回從操作數創建的 BigDecimal，創建的方法是按指定方向將小數點移動一個指定距離。

為了簡潔明瞭起見，整個 BigDecimal 方法的描述中都使用了偽程式碼。偽程式碼表達式 (i + j) 是“其值為 BigDecimal i 加 BigDecimal j 的 BigDecimal”的簡寫。偽程式碼表達式 (i == j) 是“當且僅當 BigDecimal i 表示與 BigDecimal j 相同的值時，則為 true”的簡寫。可以類似地解釋其他偽程式碼表達式。方括號用於表示特定的 BigInteger 和定義 BigDecimal 值的標度對；例如，[19, 2] 表示 BigDecimal 在數值上等於 0.19，標度是 2。

註：如果 BigDecimal 物件用作 SortedMap 中的鍵或 SortedSet 中的元素，則應特別小心，因為 BigDecimal 的自然排序與 equals 方法不一致。有關更多資訊，請參見 Comparable、SortedMap 或 SortedSet。

當為任何輸入參數傳遞 null 物件參考時，此類別的所有方法和建構子都將拋出 NullPointerException。

另請參見：: BigInteger, MathContext, RoundingMode, SortedMap, SortedSet, 序列化表格

欄位摘要
`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。

建構子摘要
`BigDecimal(BigInteger val)` 將 `BigInteger` 轉換為 `BigDecimal`。
`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)` 將 `double` 轉換為 `BigDecimal`，後者是 `double` 的二進制浮點值準確的十進製表示形式。
`BigDecimal(double val, MathContext mc)` 將 `double` 轉換為 `BigDecimal`（根據上下文設置進行捨入）。
`BigDecimal(int val)` 將 `int` 轉換為 `BigDecimal`。
`BigDecimal(int val, MathContext mc)` 將 `int` 轉換為 `BigDecimal`（根據上下文設置進行捨入）。
`BigDecimal(long val)` 將 `long` 轉換為 `BigDecimal`。
`BigDecimal(long val, MathContext mc)` 將 `long` 轉換為 `BigDecimal`（根據上下文設置進行捨入）。
`BigDecimal(String val)` 將 `BigDecimal` 的字元串表示形式轉換為 `BigDecimal`。
`BigDecimal(String val, MathContext mc)` 將 `BigDecimal` 的字元串表示形式轉換為 `BigDecimal`，接受與 `BigDecimal(String)` 建構子相同的字元串（按照上下文設置進行捨入）。

方法摘要
`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)` 返回其值為 `(this + augend)` 的 `BigDecimal`（根據上下文設置進行捨入）。
`byte`	`byteValueExact()` 將此 `BigDecimal` 轉換為 `byte`，以檢查丟失的資訊。
`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)` 返回其值為 `(this / divisor)` 的 `BigDecimal`（根據上下文設置進行捨入）。
`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()` 將此 `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)` 返回其值為 `(this × multiplicand)` 的 `BigDecimal`（根據上下文設置進行捨入）。
`BigDecimal`	`negate()` 返回 `BigDecimal`，其值為 `(-this)`，其標度為 `this.scale()`。
`BigDecimal`	`negate(MathContext mc)` 返回其值為 `(-this)` 的 `BigDecimal`（根據上下文設置進行捨入）。
`BigDecimal`	`plus()` 返回 `BigDecimal`，其值為 `(+this)`，其標度為 `this.scale()`。
`BigDecimal`	`plus(MathContext mc)` 返回其值為 `(+this)` 的 `BigDecimal`（根據上下文設置進行捨入）。
`BigDecimal`	`pow(int n)` 返回其值為 `(thisⁿ)` 的 `BigDecimal`，準確計算該冪，使其具有無限精度。
`BigDecimal`	`pow(int n, MathContext mc)` 返回其值為 `(thisⁿ)` 的 `BigDecimal`。
`int`	`precision()` 返回此 `BigDecimal` 的精度。
`BigDecimal`	`remainder(BigDecimal divisor)` 返回其值為 `(this % divisor)` 的 `BigDecimal`。
`BigDecimal`	`remainder(BigDecimal divisor, MathContext mc)` 返回其值為 `(this % divisor)` 的 `BigDecimal`（根據上下文設置進行捨入）。
`BigDecimal`	`round(MathContext mc)` 返回根據 `MathContext` 設置進行捨入後的 `BigDecimal`。
`int`	`scale()` 返回此 `BigDecimal` 的標度。
`BigDecimal`	`scaleByPowerOfTen(int n)` 返回其數值等於 (`this` * 10ⁿ) 的 BigDecimal。
`BigDecimal`	`setScale(int newScale)` 返回一個 `BigDecimal`，其標度為指定值，其值在數值上等於此 `BigDecimal` 的值。
`BigDecimal`	`setScale(int newScale, int roundingMode)` 返回一個 `BigDecimal`，其標度為指定值，其非標度值通過此 `BigDecimal` 的非標度值乘以或除以十的適當次方來確定，以維護其總值。
`BigDecimal`	`setScale(int newScale, RoundingMode roundingMode)` 返回 `BigDecimal`，其標度為指定值，其非標度值通過此 `BigDecimal` 的非標度值乘以或除以十的適當次方來確定，以維護其總值。
`short`	`shortValueExact()` 將此 `BigDecimal` 轉換為 `short`，以檢查丟失的資訊。
`int`	`signum()` 返回此 `BigDecimal` 的正負號函數。
`BigDecimal`	`stripTrailingZeros()` 返回數值上等於此小數，但從該表示形式移除所有尾部零的 `BigDecimal`。
`BigDecimal`	`subtract(BigDecimal subtrahend)` 返回一個 `BigDecimal`，其值為 `(this - subtrahend)`，其標度為 `max(this.scale(), subtrahend.scale())`。
`BigDecimal`	`subtract(BigDecimal subtrahend, MathContext mc)` 返回其值為 `(this - subtrahend)` 的 `BigDecimal`（根據上下文設置進行捨入）。
`BigInteger`	`toBigInteger()` 將此 `BigDecimal` 轉換為 `BigInteger`。
`BigInteger`	`toBigIntegerExact()` 將此 `BigDecimal` 轉換為 `BigInteger`，以檢查丟失的資訊。
`String`	`toEngineeringString()` 返回此 `BigDecimal` 的字元串表示形式，需要指數時，則使用工程計數法。
`String`	`toPlainString()` 返回不帶指數欄位的此 `BigDecimal` 的字元串表示形式。
`String`	`toString()` 返回此 `BigDecimal` 的字元串表示形式，如果需要指數，則使用科學記數法。
`BigDecimal`	`ulp()` 返回此 `BigDecimal` 的 ulp（最後一位的單位）的大小。
`BigInteger`	`unscaledValue()` 返回其值為此 `BigDecimal` 的非標度值的 `BigInteger`。
`static BigDecimal`	`valueOf(double val)` 使用 `Double.toString(double)` 方法提供的 `double` 規範的字元串表示形式將 `double` 轉換為 `BigDecimal`。
`static BigDecimal`	`valueOf(long val)` 將 `long` 值轉換為具有零標度的 `BigDecimal`。
`static BigDecimal`	`valueOf(long unscaledVal, int scale)` 將 `long` 非標度值和 `int` 標度轉換為 `BigDecimal`。

從類別 java.lang.Number 繼承的方法
`byteValue, shortValue`

從類別 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

捨入遠離零的捨入網要。在丟棄非零部分之前始終增加數字。注意，此捨入網要始終不會減少計算值的大小。

另請參見：: 常數欄位值

ROUND_DOWN

public static final int ROUND_DOWN

接近零的捨入網要。在丟棄某部分之前始終不增加數字（即截短）。注意，此捨入網要始終不會增加計算值的大小。

另請參見：: 常數欄位值

ROUND_CEILING

public static final int ROUND_CEILING

接近正無窮大的捨入網要。如果 BigDecimal 為正，則捨入行為與 ROUND_UP 相同；如果為負，則捨入行為與 ROUND_DOWN 相同。注意，此捨入網要始終不會減少計算值。

另請參見：: 常數欄位值

ROUND_FLOOR

public static final int ROUND_FLOOR

接近負無窮大的捨入網要。如果 BigDecimal 為正，則捨入行為與 ROUND_DOWN 相同；如果為負，則捨入行為與 ROUND_UP 相同。注意，此捨入網要始終不會增加計算值。

另請參見：: 常數欄位值

ROUND_HALF_UP

public static final int ROUND_HALF_UP

向“最接近的”數字捨入，如果與兩個相鄰數字的距離相等，則為向上捨入的捨入網要。如果捨棄部分 >= 0.5，則捨入行為與 ROUND_UP 相同；否則捨入行為與 ROUND_DOWN 相同。注意，這是我們大多數人在小學時就學過的捨入網要。

另請參見：: 常數欄位值

ROUND_HALF_DOWN

public static final int ROUND_HALF_DOWN

向“最接近的”數字捨入，如果與兩個相鄰數字的距離相等，則為上捨入的捨入網要。如果捨棄部分 > 0.5，則捨入行為與 ROUND_UP 相同；否則捨入行為與 ROUND_DOWN 相同。

另請參見：: 常數欄位值

ROUND_HALF_EVEN

public static final int ROUND_HALF_EVEN

向“最接近的”數字捨入，如果與兩個相鄰數字的距離相等，則向相鄰的偶數捨入。如果捨棄部分左邊的數字為奇數，則捨入行為與 ROUND_HALF_UP 相同；如果為偶數，則捨入行為與 ROUND_HALF_DOWN 相同。注意，在重複進行一系列計算時，此捨入網要可以將累加錯誤減到最小。

另請參見：: 常數欄位值

ROUND_UNNECESSARY

public static final int ROUND_UNNECESSARY

斷言請求的操作具有精確的結果，因此不需要捨入。如果對獲得精確結果的操作指定此捨入網要，則拋出 ArithmeticException。

另請參見：: 常數欄位值

建構子詳細資訊

BigDecimal

public BigDecimal(char[] in,
                  int offset,
                  int len)

將 BigDecimal 的字元陣列表示形式轉換為 BigDecimal，接受與 BigDecimal(String) 建構子相同的字元序列，同時允許指定子陣列。

注意，如果字元陣列中已經提供字元的序列，則使用此建構子要比將 char 陣列轉換為字元串並使用 BigDecimal(String) 建構子更快。

參數：: in - 作為源字元的 char 陣列。; offset - 要檢查的陣列中的第一個字元。; len - 要考慮的字元數。
拋出：: NumberFormatException - 如果 in 不是 BigDecimal 的有效表示形式，或者定義的子陣列不完全在 in 中。
從以下版本開始：: 1.5

BigDecimal

public BigDecimal(char[] in,
                  int offset,
                  int len,
                  MathContext mc)

將 BigDecimal 的字元陣列表示形式轉換為 BigDecimal，接受與 BigDecimal(String) 建構子相同的字元序列，同時允許指定子陣列，並根據上下文設置進行捨入。

注意，如果字元陣列中已經提供字元的序列，則使用此建構子要比將 char 陣列轉換為字元串並使用 BigDecimal(String) 建構子更快。

參數：: in - 作為源字元的 char 陣列。; offset - 要檢查的陣列中的第一個字元。; len - 要考慮的字元數。; mc - 要使用的上下文。
拋出：: 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 的有效表示形式。
從以下版本開始：: 1.5

BigDecimal

public BigDecimal(char[] in,
                  MathContext mc)

將 BigDecimal 的字元陣列表示形式轉換為 BigDecimal，接受與 BigDecimal(String) 建構子相同的字元序列（根據上下文設置進行捨入）。

注意，如果字元序列已經可以作為一個字元陣列使用，則使用此建構子要比將 char 陣列轉換為字元串並使用 BigDecimal(String) 建構子更快。

參數：: in - 作為源字元的 char 陣列。; mc - 要使用的上下文。
拋出：: ArithmeticException - 如果結果不準確，且捨入網要為 UNNECESSARY。; NumberFormatException - 如果 in 不是 BigDecimal 的有效表示形式。
從以下版本開始：: 1.5

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:
Character.isDigit(char) 對其返回 true 的任何字元，如 0、1、2……

返回的 BigDecimal 的標度將是小數部分中的數字位數，如果該字元串不包含小數點，則標度為零，這取決於對指數的調整；如果字元串包含一個指數，則從標度減去該指數。得到的標度值必須位於 Integer.MIN_VALUE 和 Integer.MAX_VALUE（包括）之間。

Character.digit(char, int) 集提供從字元到數字的映射，以轉換成進制 10。該字元串不能包含任何額外字元（例如，空白）。

範例：
返回的 BigDecimal 的值等於有效位數 × 10^指數。對於左邊的每個字元串，得到的表示形式 [BigInteger, scale] 顯示在右邊。

 "0"            [0,0]
 "0.00"         [0,2]
 "123"          [123,0]
 "-123"         [-123,0]
 "1.23E3"       [123,-1]
 "1.23E+3"      [123,-1]
 "12.3E+7"      [123,-6]
 "12.0"         [120,1]
 "12.3"         [123,1]
 "0.00123"      [123,5]
 "-1.23E-12"    [-123,14]
 "1234.5E-4"    [12345,5]
 "0E+7"         [0,-7]
 "-0"           [0,0]

註：對於不是 float、double NaN 和 ±Infinity 的值，此建構子與 Float.toString(float) 和 Double.toString(double) 返回的值相容。這通常是將 float 或 double 轉換為 BigDecimal 的首選方法，因為它不會遇到 BigDecimal(double) 建構子的不可預知問題。

參數：: val - BigDecimal 的字元串表示形式。
拋出：: NumberFormatException - 如果 val 不是 BigDecimal 的有效表示形式。

BigDecimal

public BigDecimal(String val,
                  MathContext mc)

將 BigDecimal 的字元串表示形式轉換為 BigDecimal，接受與 BigDecimal(String) 建構子相同的字元串（按照上下文設置進行捨入）。

參數：: val - BigDecimal 的字元串表示形式。; mc - 要使用的上下文。
拋出：: ArithmeticException - 如果結果不準確，且捨入網要為 UNNECESSARY。; NumberFormatException - 如果 val 不是 BigDecimal 的有效表示形式。
從以下版本開始：: 1.5

BigDecimal

public BigDecimal(double val)

將 double 轉換為 BigDecimal，後者是 double 的二進制浮點值準確的十進製表示形式。返回的 BigDecimal 的標度是使 (10^scale × val) 為整數的最小值。

註：

此建構子的結果有一定的不可預知性。有人可能認為在 Java 中寫入 new BigDecimal(0.1) 所創建的 BigDecimal 正好等於 0.1（非標度值 1，其標度為 1），但是它實際上等於 0.1000000000000000055511151231257827021181583404541015625。這是因為 0.1 無法準確地表示為 double（或者說對於該情況，不能表示為任何有限長度的二進制小數）。這樣，傳入到建構子的值不會正好等於 0.1（雖然表面上等於該值）。
另一方面，String 建構子是完全可預知的：寫入 new BigDecimal("0.1") 將創建一個 BigDecimal，它正好等於預期的 0.1。因此，比較而言，通常建議優先使用 String 建構子。
當 double 必須用作 BigDecimal 的源時，請注意，此建構子提供了一個準確轉換；它不提供與以下操作相同的結果：先使用 Double.toString(double) 方法，然後使用 BigDecimal(String) 建構子，將 double 轉換為 String。要獲取該結果，請使用 static valueOf(double) 方法。

參數：: val - 要轉換為 BigDecimal 的 double 值。
拋出：: NumberFormatException - 如果 val 為無窮大或 NaN。

BigDecimal

public BigDecimal(double val,
                  MathContext mc)

將 double 轉換為 BigDecimal（根據上下文設置進行捨入）。BigDecimal 的標度是使 (10^scale × val) 為整數的最小值。

此建構子的結果有一定的不可預知性，通常不建議使用它，請參見 BigDecimal(double) 建構子下面的註釋。

參數：: val - 要轉換為 BigDecimal 的 double 值。; mc - 要使用的上下文。
拋出：: ArithmeticException - 如果結果不準確，但是 RoundingMode 為 UNNECESSARY。; NumberFormatException - 如果 val 為無窮大或 NaN。
從以下版本開始：: 1.5

BigDecimal

public BigDecimal(BigInteger val)

將 BigInteger 轉換為 BigDecimal。BigDecimal 的標度是零。

參數：: val - 要轉換為 BigDecimal 的 BigInteger 值。

BigDecimal

public BigDecimal(BigInteger val,
                  MathContext mc)

將 BigInteger 轉換為 BigDecimal（根據上下文設置進行捨入）。BigDecimal 的標度為零。

參數：: val - 要轉換為 BigDecimal 的 BigInteger 值。; mc - 要使用的上下文。
拋出：: ArithmeticException - 如果結果不準確，但是捨入網要為 UNNECESSARY。
從以下版本開始：: 1.5

BigDecimal

public BigDecimal(BigInteger unscaledVal,
                  int scale)

將 BigInteger 非標度值和 int 標度轉換為 BigDecimal。BigDecimal 的值為 (unscaledVal × 10^-scale)。

參數：: unscaledVal - BigDecimal 的非標度值。; scale - BigDecimal 的標度。

BigDecimal

public BigDecimal(BigInteger unscaledVal,
                  int scale,
                  MathContext mc)

將 BigInteger 非標度值和 int 標度轉換為 BigDecimal（根據上下文設置進行捨入）。BigDecimal 的值為 (unscaledVal × 10^-scale)，它是根據 precision 和捨入網要設置進行捨入的。

參數：: unscaledVal - BigDecimal 的非標度值。; scale - BigDecimal 的標度。; mc - 要使用的上下文。
拋出：: ArithmeticException - 如果結果不準確，但是捨入網要為 UNNECESSARY。
從以下版本開始：: 1.5

BigDecimal

public BigDecimal(int val)

將 int 轉換為 BigDecimal。BigDecimal 的標度為零。

參數：: val - 要轉換為 BigDecimal 的 int 值。
從以下版本開始：: 1.5

BigDecimal

public BigDecimal(int val,
                  MathContext mc)

將 int 轉換為 BigDecimal（根據上下文設置進行捨入）。在進行任何捨入之前，BigDecimal 的標度為零。

參數：: val - 要轉換為 BigDecimal 的 int 值。; mc - 要使用的上下文。
拋出：: ArithmeticException - 如果結果不準確，但是捨入網要為 UNNECESSARY。
從以下版本開始：: 1.5

BigDecimal

public BigDecimal(long val)

將 long 轉換為 BigDecimal。BigDecimal 的標度為零。

參數：: val - 要轉換為 BigDecimal 的 long 值。
從以下版本開始：: 1.5

BigDecimal

public BigDecimal(long val,
                  MathContext mc)

將 long 轉換為 BigDecimal（根據上下文設置進行捨入）。在進行任何捨入之前，BigDecimal 的標度為零。

參數：: val - 要轉換為 BigDecimal 的 long 值。; mc - 要使用的上下文。
拋出：: ArithmeticException - 如果結果不準確，但是捨入網要為 UNNECESSARY。
從以下版本開始：: 1.5

方法詳細資訊

valueOf

public static BigDecimal valueOf(long unscaledVal,
                                 int scale)

將 long 非標度值和 int 標度轉換為 BigDecimal。提供的此“靜態處理器方法”優先於 (long, int) 建構子，因為前者允許重用經常使用的 BigDecimal 值。

參數：: unscaledVal - BigDecimal 的非標度值。; scale - BigDecimal 的標度。
返回：: 其值為 (unscaledVal × 10^-scale) 的 BigDecimal。

valueOf

public static BigDecimal valueOf(long val)

將 long 值轉換為具有零標度的 BigDecimal。提供的此“靜態處理器方法”優先於 (long) 建構子，因為前者允許重用經常使用的 BigDecimal 值。

參數：: val - BigDecimal 的值。
返回：: 其值為 val 的 BigDecimal。

valueOf

public static BigDecimal valueOf(double val)

使用 Double.toString(double) 方法提供的 double 規範的字元串表示形式將 double 轉換為 BigDecimal。

註：這通常是將 double（或 float）轉化為 BigDecimal 的首選方法，因為返回的值等於從建構 BigDecimal（使用 Double.toString(double) 得到的結果）得到的值。

參數：: val - 要轉換為 BigDecimal 的 double。
返回：: 其值等於或約等於 val 值的 BigDecimal。
拋出：: 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)

返回其值為 (this + augend) 的 BigDecimal（根據上下文設置進行捨入）。如果任一數字為零，並且精度設置為非零，則其他數字（必要時進行捨入）可以作為結果。

參數：: augend - 將添加到此 BigDecimal 中的值。; mc - 要使用的上下文。
返回：: this + augend，必要時進行捨入。
拋出：: 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)

返回其值為 (this - subtrahend) 的 BigDecimal（根據上下文設置進行捨入）。如果 subtrahend 為零，則將其（必要時進行捨入）作為結果。如果為零，則該結果是 subtrahend.negate(mc)。

參數：: subtrahend - 從此 BigDecimal 減去的值。; mc - 要使用的上下文。
返回：: this - subtrahend，必要時進行捨入。
拋出：: ArithmeticException - 如果結果不準確，但是捨入網要為 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)

返回其值為 (this × multiplicand) 的 BigDecimal（根據上下文設置進行捨入）。

參數：: multiplicand - 乘以此 BigDecimal 的值。; mc - 要使用的上下文。
返回：: 必要時捨入的 this * multiplicand。
拋出：: 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)

返回其值為 (this / divisor) 的 BigDecimal（根據上下文設置進行捨入）。

參數：: divisor - 此 BigDecimal 要除以的值。; mc - 要使用的上下文。
返回：: this / divisor，必要時進行捨入。
拋出：: ArithmeticException - 如果結果不準確，但是捨入網要為 UNNECESSARY 或 mc.precision == 0，並且商值具有無窮的十進制擴展。
從以下版本開始：: 1.5

divideToIntegralValue

public BigDecimal divideToIntegralValue(BigDecimal divisor)

返回 BigDecimal，其值為向下捨入所得商值 (this / divisor) 的整數部分。該結果的首選標度為 (this.scale() - divisor.scale())。

參數：: divisor - 此 BigDecimal 要除以的值。
返回：: this / divisor 的整數部分。
拋出：: ArithmeticException - 如果 divisor==0
從以下版本開始：: 1.5

divideToIntegralValue

public BigDecimal divideToIntegralValue(BigDecimal divisor,
                                        MathContext mc)

返回 BigDecimal，其值為 (this / divisor) 的整數部分。因為準確商值的整數部分與捨入網要無關，所以捨入網要不影響此方法返回的值。該結果的首選標度是 (this.scale() - divisor.scale())。如果準確商值的整數部分需要的位數多於 mc.precision，則拋出 ArithmeticException。

參數：: divisor - 此 BigDecimal 要相除的值。; mc - 要使用的上下文。
返回：: this / divisor 的整數部分。
拋出：: ArithmeticException - 如果 divisor==0; ArithmeticException - 如果 mc.precision > 0，並且該結果需要的精度大於 mc.precision。
從以下版本開始：: 1.5

remainder

public BigDecimal remainder(BigDecimal divisor)

返回其值為 (this % divisor) 的 BigDecimal。

餘數由 this.subtract(this.divideToIntegralValue(divisor).multiply(divisor)) 給出。注意，這不是模操作（結果可以為負）。

參數：: divisor - 此 BigDecimal 要除以的值。
返回：: this % divisor。
拋出：: ArithmeticException - 如果 divisor==0
從以下版本開始：: 1.5

remainder

public BigDecimal remainder(BigDecimal divisor,
                            MathContext mc)

返回其值為 (this % divisor) 的 BigDecimal（根據上下文設置進行捨入）。MathContext 設置會影響用於計算餘數的隱式除法。餘數計算本身要進行準確的定義。因此，餘數包含的數字個數可能多於 mc.getPrecision()。

餘數由 this.subtract(this.divideToIntegralValue(divisor, mc).multiply(divisor)) 給出。注意，這不是模操作（結果可以為負）。

參數：: divisor - 此 BigDecimal 要相除的值。; mc - 要使用的上下文。
返回：: this % divisor，必要時進行捨入。
拋出：: ArithmeticException - 如果 divisor==0; ArithmeticException - 如果結果不準確，但捨入網要為 UNNECESSARY，或者 mc.precision > 0，並且 this.divideToIntgralValue(divisor) 的結果要求的精度大於 mc.precision。
從以下版本開始：: 1.5
另請參見：: divideToIntegralValue(java.math.BigDecimal, java.math.MathContext)

divideAndRemainder

public BigDecimal[] divideAndRemainder(BigDecimal divisor)

返回由兩個元素組成的 BigDecimal 陣列，該陣列包含 divideToIntegralValue 的結果，後跟對兩個操作數計算所得到的 remainder。

注意，如果同時需要整數商和餘數，則此方法比分別使用 divideToIntegralValue 和 remainder 方法更快速，因為相除僅需執行一次。

參數：: divisor - 此 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 和 remainder 方法更快速，因為相除僅需執行一次。

參數：: divisor - 此 BigDecimal 要相除的值和計算的餘數。; mc - 要使用的上下文。
返回：: 由兩個元素組成的 BigDecimal 陣列：商值（divideToIntegralValue 的結果）是初始元素，餘數是最終元素。
拋出：: ArithmeticException - 如果 divisor==0; ArithmeticException - 如果結果不準確，但捨入網要為 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)

返回其值為 (thisⁿ) 的 BigDecimal，準確計算該冪，使其具有無限精度。

參數 n 必須在 0 到 999999999（包括）之間。ZERO.pow(0) 返回 ONE。注意，未來版本可能會擴展此方法允許的指數範圍。

參數：: n - 此 BigDecimal 的冪。
返回：: thisⁿ
拋出：: ArithmeticException - 如果 n 超出範圍。
從以下版本開始：: 1.5

pow

public BigDecimal pow(int n,
                      MathContext mc)

返回其值為 (thisⁿ) 的 BigDecimal。當前實作使用的是 ANSI 標準 X3.274-1996 中定義的核心演算法（根據上下文設置進行捨入）。一般情況下，返回的數值在具有選擇精度的精確數值的兩個 ulp 中。注意，未來版本可以使用不同的演算法，以減少允許的錯誤範圍，並增加允許的指數範圍。

X3.274-1996 演算法為：

如果出現以下情況，則拋出 ArithmeticException 異常
- abs(n) > 999999999
- mc.precision == 0 且 n < 0
- mc.precision > 0 且 n 大於 mc.precision
如果 n 為零，則返回 ONE（即使 this 為零），否則
- 如果 n 為正數，則通過重複的平方技術將此結果計算到一個累加器中。每個附帶累加器的乘法都使用與 mc 中相同的數學上下文設置，增加到 mc.precision + elength + 1 的精度除外，其中 elength 表示 n 中的十進制數字的個數。
- 如果 n 為負數，則將 n 視為正數計算其結果；然後使用上面指定的工作精度，用一除以此值。
- 然後將正數或負數的最終值捨入為目標精度。

參數：: n - 此 BigDecimal 的冪。; mc - 要使用的上下文。
返回：: 使用 ANSI 標準 X3.274-1996 演算法的 thisⁿ
拋出：: ArithmeticException - 如果該結果不準確，但是捨入網要為 UNNECESSARY，或者 n 超出範圍。
從以下版本開始：: 1.5

abs

public BigDecimal abs()

返回 BigDecimal，其值為此 BigDecimal 的絕對值，其標度為 this.scale()。

返回：: abs(this)

abs

public BigDecimal abs(MathContext mc)

返回其值為此 BigDecimal 絕對值的 BigDecimal（根據上下文設置進行捨入）。

參數：: mc - 要使用的上下文。
返回：: abs(this)，必要時進行捨入。
拋出：: ArithmeticException - 如果結果不準確，但是捨入網要為 UNNECESSARY。
從以下版本開始：: 1.5

negate

public BigDecimal negate()

返回 BigDecimal，其值為 (-this)，其標度為 this.scale()。

返回：: -this。

negate

public BigDecimal negate(MathContext mc)

返回其值為 (-this) 的 BigDecimal（根據上下文設置進行捨入）。

參數：: mc - 要使用的上下文。
返回：: abs(this)，必要時進行捨入。
拋出：: ArithmeticException - 如果結果不準確，但是捨入網要為 UNNECESSARY。
從以下版本開始：: 1.5

plus

public BigDecimal plus()

返回 BigDecimal，其值為 (+this)，其標度為 this.scale()。

此方法僅返回此 BigDecimal，該方法與一元減方法 negate() 對稱。

返回：: this。
從以下版本開始：: 1.5
另請參見：: negate()

plus

public BigDecimal plus(MathContext mc)

返回其值為 (+this) 的 BigDecimal（根據上下文設置進行捨入）。

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

參數：: mc - 要使用的上下文。
返回：: this，必要時進行捨入。零結果具有的標度為 0。
拋出：: ArithmeticException - 如果結果不準確，但是捨入網要為 UNNECESSARY。
從以下版本開始：: 1.5
另請參見：: round(MathContext)

signum

public int signum()

返回此 BigDecimal 的正負號函數。

返回：: 當此 BigDecimal 的值為負、零或正時，返回 -1、0 或 1。

scale

public int scale()

返回此 BigDecimal 的標度。如果為零或正數，則標度是小數點後的位數。如果為負數，則將該數的非標度值乘以 10 的負 scale 次方。例如，-3 標度是指非標度值乘以 1000。

返回：: 此 BigDecimal 的標度。

precision

public int precision()

返回此 BigDecimal 的精度。（精度是非標度值的數字個數。）

零值的精度是 1。

返回：: 此 BigDecimal 的精度。
從以下版本開始：: 1.5

unscaledValue

public BigInteger unscaledValue()

返回其值為此 BigDecimal 的非標度值 的 BigInteger。（計算 (this * 10^this.scale())。）

返回：: 此 BigDecimal 的非標度值。
從以下版本開始：: 1.2

round

public BigDecimal round(MathContext mc)

返回根據 MathContext 設置進行捨入後的 BigDecimal。如果精度設置為 0，則不進行任何捨入操作。

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

參數：: mc - 要使用的上下文。
返回：: 根據 MathContext 設置捨入後的 BigDecimal。
拋出：: ArithmeticException - 如果捨入網要為 UNNECESSARY，並且 BigDecimal 操作要求進行捨入。
從以下版本開始：: 1.5
另請參見：: plus(MathContext)

setScale

public BigDecimal setScale(int newScale,
                           RoundingMode roundingMode)

返回 BigDecimal，其標度為指定值，其非標度值通過此 BigDecimal 的非標度值乘以或除以十的適當次方來確定，以維護其總值。如果該操作減少標度，則非標度值必須被除（而不是乘），並且該值可以更改；在這種情況下，將指定的捨入網要應用到除法中。

參數：: newScale - 要返回的 BigDecimal 值的標度。; roundingMode - 要應用的捨入網要。
返回：: 一個 BigDecimal，其標度為指定值，其非標度值可以通過此 BigDecimal 的非標度值乘以或除以十的適當次方來確定，以維護其總值。
拋出：: ArithmeticException - 如果 roundingMode==UNNECESSARY，並且指定的標度操作要求進行捨入。
從以下版本開始：: 1.5
另請參見：: RoundingMode

setScale

public BigDecimal setScale(int newScale,
                           int roundingMode)

返回一個 BigDecimal，其標度為指定值，其非標度值通過此 BigDecimal 的非標度值乘以或除以十的適當次方來確定，以維護其總值。如果該操作減少標度，則非標度值必須被除（而不是乘），並且該值可以更改；在這種情況下，將指定的捨入網要應用到除法中。

注意，由於 BigDecimal 物件是不可變的，此方法的調用不會導致初始物件被修改，這與使用名為 setX 變異欄位 X 方法的常規約定相反。相反，setScale 返回具有適當標度的物件；返回的物件不一定是新分派的。

相對於此遺留方法，應優先使用新的 setScale(int, RoundingMode) 方法。

參數：: newScale - 要返回的 BigDecimal 值的標度。; roundingMode - 要應用的捨入網要。
返回：: 一個 BigDecimal，其標度為指定值，其非標度值可以通過此 BigDecimal 的非標度值乘以或除以十的適當次方來確定。
拋出：: ArithmeticException - 如果 roundingMode==ROUND_UNNECESSARY，並且指定的標度操作要求進行捨入。; IllegalArgumentException - 如果 roundingMode 不表示一個有效的捨入網要。
另請參見：: ROUND_UP, ROUND_DOWN, ROUND_CEILING, ROUND_FLOOR, ROUND_HALF_UP, ROUND_HALF_DOWN, ROUND_HALF_EVEN, ROUND_UNNECESSARY

setScale

public BigDecimal setScale(int newScale)

返回一個 BigDecimal，其標度為指定值，其值在數值上等於此 BigDecimal 的值。如果這不可能，則拋出 ArithmeticException。

此調用通常用於增加標度，在這種情況下，可以保證存在指定標度和正確值的 BigDecimal。如果調用方知道 BigDecimal在其小數部分的結尾有足夠多的零（即其整數值中的十的因子），則該調用也可用於減少標度，以允許重新標度，而不更改其值。

此方法返回與 setScale 的兩個參數版本相同的結果，但是，為調用方省去了指定捨入網要的麻煩（捨入網要不影響結果）。

注意，由於 BigDecimal 物件是不可變的，因此此方法的調用不會導致初始物件被修改，這與使用名為 setX 變異欄位 X 方法的常規約定相反。相反，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ⁿ) 的 BigDecimal。該結果的標度為 (this.scale() - n)。

拋出：: ArithmeticException - 如果該標度的範圍超出 32 位整數的範圍。
從以下版本開始：: 1.5

stripTrailingZeros

public BigDecimal stripTrailingZeros()

返回數值上等於此小數，但從該表示形式移除所有尾部零的 BigDecimal。例如，從 BigDecimal 值 600.0 中移除尾部零，該值具有的 [BigInteger, scale] 元件等於 [6000, 1]，使用 [BigInteger, scale] 元件產生的 6E2 等於 [6, -2]

返回：: 數值上等於移除所有尾部零的 BigDecimal。
從以下版本開始：: 1.5

compareTo

public int compareTo(BigDecimal val)

將此 BigDecimal 與指定的 BigDecimal 比較。根據此方法，值相等但具有不同標度的兩個 BigDecimal 物件（如，2.0 和 2.00）被認為是相等的。相對六個 boolean 比較運算符 (<, ==, >, >=, !=, <=) 中每一個運算符的各個方法，優先提供此方法。建議使用以下語句執行上述比較：(x.compareTo(y) <op> 0)，其中 <op> 是六個比較運算符之一。

指定者：: 介面 Comparable<BigDecimal> 中的 compareTo

參數：: val - 將此 BigDecimal 與之比較的 BigDecimal。
返回：: 當此 BigDecimal 在數字上小於、等於或大於 val 時，返回 -1、0 或 1。

equals

public boolean equals(Object x)

比較此 BigDecimal 與指定的 Object 的相等性。與 compareTo 不同，僅當兩個 BigDecimal 物件的值和標度都相等時，此方法才認為它們相等（因此通過此方法進行比較時，2.0 不等於 2.00）。

覆寫：: 類別 Object 中的 equals

參數：: x - 將與此 BigDecimal 進行比較的 Object。
返回：: 當且僅當指定的 Object 為 BigDecimal，並且其值和標度都等於此 BigDecimal 的值和標度時，返回 true。
另請參見：: compareTo(java.math.BigDecimal), hashCode()

min

public BigDecimal min(BigDecimal val)

返回此 BigDecimal 和 val 的最小值。

參數：: val - 要計算最小值的值。
返回：: 其值為 BigDecimal 和 val 中較小值的 BigDecimal。根據 compareTo 方法的定義，如果它們相等，則返回 this。
另請參見：: compareTo(java.math.BigDecimal)

max

public BigDecimal max(BigDecimal val)

返回此 BigDecimal 和 val 的最大值。

參數：: val - 要計算最大值的值。
返回：: 其值為此 BigDecimal 和 val 中較大值的 BigDecimal。根據 compareTo 方法的定義，如果它們相等，則返回 this。
另請參見：: compareTo(java.math.BigDecimal)

hashCode

public int hashCode()

返回此 BigDecimal 的雜湊碼。注意，數值上相等但標度不同的兩個 BigDecimal 物件（如，2.0 和 2.00）通常沒有相同的雜湊碼。

覆寫：: 類別 Object 中的 hashCode

返回：: 此 BigDecimal 的雜湊碼。
另請參見：: equals(Object)

toString

public String toString()

返回此 BigDecimal 的字元串表示形式，如果需要指數，則使用科學記數法。

根據以下步驟可創建 BigDecimal 的標準的規範化字元串形式：首先，使用不帶前導零的字元 '0' 至 '9'（如果其值為零，則使用單個 '0' 字元）將 BigDecimal 的非標度值的絕對值轉換為以十為進制的字元串。

其次，計算調整的指數；這是無效的標度，加上轉換的非標度值中的字元數減 1。即：-scale+(ulength-1)，其中 ulength 是十進制數字中非標度值的絕對值的長度（其精度）。

如果該標度大於或等於零，並且調整的指數大於或等於 -6，則在不使用指數記數法的情況下將該數轉換為字元形式。在這種情況下，如果標度為零，則不添加小數點，如果標度為正數，則插入小數點，且標度指定了小數點右邊的字元個數。必要時，將字元 '0' 添加到轉換的非標度值的左邊。如果插入後小數點前面沒有字元，則以傳統字元 '0' 為前綴。

否則（即：如果標度為負數，或者調整的指數小於 -6），使用指數記數法將該數轉換為字元形式。在這種情況下，如果轉換後的 BigInteger 多於一位數，則小數點插入在第一個數字之後。然後，將字元形式的指數作為轉換的非標度值（也許具有插入的小數點）的後綴；這包含字母 'E' 和直接跟在其後的轉換為字元形式的調整指數。後者的進制為十，使用的字元是 '0' 到 '9'，沒有前導零，並且，如果調整的指數為負數，則總是以符號字元 '-' ('\u002D') 為前綴，否則以 '+' ('\u002B') 為前綴。

最後，如果非標度值小於零，則整個字元串以減號 '-' ('\u002D') 為前綴。如果非標度值為零或正數，則不使用符號字元作為前綴。

範例：

對於左邊的每個表示形式 [unscaled value, scale]，得到的字元串顯示在右邊。

 [123,0]      "123"
 [-123,0]     "-123"
 [123,-1]     "1.23E+3"
 [123,-3]     "1.23E+5"
 [123,1]      "12.3"
 [123,5]      "0.00123"
 [123,10]     "1.23E-8"
 [-123,12]    "-1.23E-10"

註：

可區分的 BigDecimal 值和此轉換的結果之間存在一對一的映射關係。即：每個可區分的 BigDecimal 值（非標度值和標度）都有唯一的字元串表示形式，作為使用 toString 的結果。如果使用 BigDecimal(String) 建構子將該字元串表示形式轉換為 BigDecimal，則將恢復初始值。
給定的數產生的字元串總是相同的；它不受語言環境的影響。這意味著它可以用作交換十進制資料的規範化字元串表示形式，或用作 Hashtable 的關鍵字等等。NumberFormat 類別及其子類別可以處理區分語言環境的數的格式化和分析。
toEngineeringString() 方法可用於在工程計數法中表示帶有指數的數。setScale 方法可用於對 BigDecimal 進行捨入，使其小數點後的位數為已知位數。
使用 Character.forDigit 提供的數字到字元的映射關係。

覆寫：: 類別 Object 中的 toString

返回：: 此 BigDecimal 的字元串表示形式。
另請參見：: Character.forDigit(int, int), BigDecimal(java.lang.String)

toEngineeringString

public String toEngineeringString()

返回此 BigDecimal 的字元串表示形式，需要指數時，則使用工程計數法。

返回如 toString() 方法中所描述的表示 BigDecimal 的字元串，不包括使用指數記數法的情況，將十的冪調整為三的倍數（工程記數法），這樣，非零值的整數部分的範圍是 1 到 999。如果對零值使用指數記數法，則使用小數點和小數的一（或二）個零數字，以便保留零值的標度。注意，與 toString() 的輸出不同，如果使用 string constructor 將輸出字元串轉換為 BigDecimal，則此方法的輸出不保證恢復此 BigDecimal 的相同 [integer, scale] 對。此方法滿足以下較弱約束，即產生的結果在數值上始終等於將字元串建構子應用到方法的輸出得到的結果。

返回：: 此 BigDecimal 的字元串表示形式，如果需要指數，則使用工程記數法。
從以下版本開始：: 1.5

toPlainString

public String toPlainString()

返回不帶指數欄位的此 BigDecimal 的字元串表示形式。對於具有正標度的值，小數點右邊的數字個數用於指示標度。對於具有零或負標度的值，產生得到的字元串，好像將該值轉換為在數值上等於具有零標度的值一樣，並且好像零標度值的所有尾部零都出現在該結果中。如果非標度值小於零，則整個字元串以減號 '-' ('\u002D') 為前綴。如果非標度值為零或正數，則沒有任何符號字元作為前綴。注意，如果將此方法的結果傳遞到 string constructor，則只需要恢復此 BigDecimal 的數值；新的 BigDecimal 的表示形式可以有不同的標度。尤其是，如果此 BigDecimal 具有負標度，則在由字元串建構子進行處理時，此方法產生的字元串將具有零標度。（此方法的作用類似於 1.4 和更早版本中的 toString 方法。）

返回：: 不帶指數欄位的此 BigDecimal 的字元串表示形式。
從以下版本開始：: 1.5
另請參見：: toString(), toEngineeringString()

toBigInteger

public BigInteger toBigInteger()

將此 BigDecimal 轉換為 BigInteger。此轉換類似於 Java Language Specification 中定義的從 double 到 long 的基本收縮轉換：將丟棄此 BigDecimal 的小數部分。注意，此轉換會丟失關於 BigDecimal 值的精度資訊。

要在轉換不準確時（即當丟棄非零小數部分時）拋出異常，請使用 toBigIntegerExact() 方法。

返回：: 轉換為 BigInteger 的此 BigDecimal。

toBigIntegerExact

public BigInteger toBigIntegerExact()

將此 BigDecimal 轉換為 BigInteger，以檢查丟失的資訊。如果此 BigDecimal 具有非零小數部分，則拋出一個異常。

返回：: 轉換為 BigInteger 的此 BigDecimal。
拋出：: ArithmeticException - 如果 this 具有非零小數部分。
從以下版本開始：: 1.5

longValue

public long longValue()

將此 BigDecimal 轉換為 long。此轉換類似於 Java Language Specification 中定義的從 double 到 short 的基本收縮轉換：將丟棄此 BigDecimal 的小數部分，並且如果產生的 "BigInteger" 太大而不適合用 long 表示，則僅返回 64 位低位位元組。注意，此轉換會丟失關於此 BigDecimal 值的總大小和精度的資訊，並返回帶有相反符號的結果。

指定者：: 類別 Number 中的 longValue

返回：: 轉換為 long 的此 BigDecimal。

longValueExact

public long longValueExact()

將此 BigDecimal 轉換為 long，以檢查丟失的資訊。如果此 BigDecimal 具有非零小數部分，或者超出 long 結果的可能範圍，則拋出 ArithmeticException。

返回：: 轉換為 long 的此 BigDecimal。
拋出：: ArithmeticException - 如果 this 具有非零小數部分，或者不適合用 long 表示。
從以下版本開始：: 1.5

intValue

public int intValue()

將此 BigDecimal 轉換為 int。此轉換類似於 Java Language Specification 中定義的從 double 到 short 的基本收縮轉換：將丟棄此 BigDecimal 的所有小數部分，並且如果產生的 "BigInteger" 太大而不適合用 int 表示，則僅返回 32 位低位位元組。注意，此轉換會丟失關於此 BigDecimal 值的總大小和精度的資訊，並返回帶有相反符號的結果。

指定者：: 類別 Number 中的 intValue

返回：: 轉換為 int 的此 BigDecimal。

intValueExact

public int intValueExact()

將此 BigDecimal 轉換為 int，以檢查丟失的資訊。如果此 BigDecimal 具有非零小數部分，或者超出 int 結果的可能範圍，則拋出 ArithmeticException。

返回：: 轉換為 int 的此 BigDecimal。
拋出：: ArithmeticException - 如果 this 具有非零小數部分，或者不適合用 int 表示。
從以下版本開始：: 1.5

shortValueExact

public short shortValueExact()

將此 BigDecimal 轉換為 short，以檢查丟失的資訊。如果此 BigDecimal 具有非零小數部分，或者超出 short 結果的可能範圍，則拋出 ArithmeticException。

返回：: 轉換為 short 的此 BigDecimal。
拋出：: ArithmeticException - 如果 this 具有非零小數部分，或者不適合用 short 表示。
從以下版本開始：: 1.5

byteValueExact

public byte byteValueExact()

將此 BigDecimal 轉換為 byte，以檢查丟失的資訊。如果此 BigDecimal 具有非零小數部分，或者超出 byte 結果的可能範圍，則拋出 ArithmeticException。

返回：: 轉換為 byte 的此 BigDecimal。
拋出：: ArithmeticException - 如果 this 具有非零小數部分，或者不適合用 byte 表示。
從以下版本開始：: 1.5

floatValue

public float floatValue()

將此 BigDecimal 轉換為 float。此轉換類似於 Java Language Specification 中定義的從 double 到 float 的基本收縮轉換：如此 BigDecimal 的值太大而不能表示為 float，則將其適當地轉換為 Float.NEGATIVE_INFINITY 或 Float.POSITIVE_INFINITY。注意，即使在返回值為有限值的情況下，此轉換也可能丟失關於 BigDecimal 值精度的資訊。

指定者：: 類別 Number 中的 floatValue

返回：: 轉換為 float 的此 BigDecimal。

doubleValue

public double doubleValue()

將此 BigDecimal 轉換為 double。此轉換類似於 Java Language Specification 中定義的從 double 到 float 的 基本收縮轉換：如果此 BigDecimal 的數量太大而不能表示為 double，則將其適當地轉換為 Double.NEGATIVE_INFINITY 或 Double.POSITIVE_INFINITY。注意，即使在返回值為有限值的情況下，此轉換也可能丟失關於 BigDecimal 值精度的資訊。

指定者：: 類別 Number 中的 doubleValue

返回：: 轉換為 double 的此 BigDecimal。

ulp

public BigDecimal ulp()

返回此 BigDecimal 的 ulp（最後一位的單位）的大小。非零 BigDecimal 值的 ulp 是此值與下一個具有相同位數的較大 BigDecimal 值之間的正距離。零值的 ulp 在數值上等於具有 this 標度的 1。使用與 this 相同的標度存儲該結果，這樣，零和非零值的結果等於 [1, this.scale()]。

返回：: this 的 ulp 的大小
從以下版本開始：: 1.5

概觀

軟體套件

類別

使用

階層樹

已過時

索引

說明

Java^TM 2 Platform
Standard Ed. 6

上一個類別 下一個類別

框架 無框架

摘要：巢狀 | 欄位 | 建構子 | 方法

詳細資訊：欄位 | 建構子 | 方法

提交錯誤或意見

java.math 類別 BigDecimal

算術運算結果的首選標度

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

max

hashCode

toString

toEngineeringString

toPlainString

toBigInteger

toBigIntegerExact

java.math
類別 BigDecimal