模块  java.base
软件包  java.math

Class BigDecimal

  • 实现的所有接口
    Serializable ， Comparable<BigDecimal> 
    public class BigDecimal
extends Number
implements Comparable<BigDecimal>
    不可变的，任意精度的带符号十进制数。 A BigDecimal由任意精度整数非标度值和32位整数标度组成 。 如果为零或正数，则比例是小数点右侧的位数。 如果是负数，则将数字的未缩放值乘以10来表示比例的否定。 因此， (unscaledValue × 10-scale)代表的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算法的规则与ANSI X3.274-1996和ANSI X3.274-1996 / AM 1-2000（第7.4节）中定义的算术的选定操作模式大致兼容。 与那些标准不同， BigDecimal包括许多舍入模式，这些模式在BigDecimal之前的BigDecimal版本中是必需的。这些ANSI标准和BigDecimal规范之间的任何冲突都有利于BigDecimal 。

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

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

    对于所有算术运算符，执行操作就像首先计算精确的中间结果一样，然后使用选定的舍入模式舍入到精度设置（如果需要）指定的位数。 如果未返回确切结果，则丢弃确切结果的某些数字位置。 当舍入增加返回结果的幅度时，可以通过传播到前导“9”数字的进位来创建新的数字位置。 例如，将值999.9舍入到三位数四舍五入将在数字上等于一千，表示为100×10 1 。 在这种情况下，新的“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() Square root radicand.scale()/2
    这些尺度是返回精确算术结果的方法所使用的尺度; 除了精确的除法可能必须使用更大的比例，因为确切的结果可能有更多的数字。 例如， 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

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

    其他方法可能具有略微不同的舍入语义。 例如，使用specified algorithm的pow方法的结果有时可能与舍入的数学结果有所不同，最后一个位置是一个ulp 。

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

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

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

    API Note:
    如果BigDecimal对象用作BigDecimal中的键或SortedSet中的元素， 则应谨慎行事，因为BigDecimal的自然顺序 与equals不一致 。 见Comparable ， SortedMap或SortedSet获取更多信息。
    从以下版本开始：
    1.1
    另请参见：
    BigInteger ， MathContext ， RoundingMode ， SortedMap ， SortedSet ， Serialized Form

    • 字段详细信息

      • 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

        @Deprecated(since="9")
public static final int ROUND_UP
        Deprecated.
        Use RoundingMode.UP instead.
        舍入模式从零开始舍入。 始终在非零丢弃分数之前递增数字。 请注意，此舍入模式决不会降低计算值的大小。
        另请参见：
        常数字段值

      • ROUND_DOWN

        @Deprecated(since="9")
public static final int ROUND_DOWN
        Deprecated.
        Use RoundingMode.DOWN instead.
        舍入模式向零舍入。 切勿在丢弃的分数之前递增数字（即截断）。 请注意，此舍入模式永远不会增加计算值的大小。
        另请参见：
        常数字段值

      • ROUND_CEILING

        @Deprecated(since="9")
public static final int ROUND_CEILING
        Deprecated.
        Use RoundingMode.CEILING instead.
        舍入模式向正无穷大舍入。 如果BigDecimal为正，则表现为ROUND_UP ; 如果为负，则表现为ROUND_DOWN 。 请注意，此舍入模式永远不会减少计算值。
        另请参见：
        常数字段值

      • ROUND_FLOOR

        @Deprecated(since="9")
public static final int ROUND_FLOOR
        Deprecated.
        Use RoundingMode.FLOOR instead.
        舍入模式向负无穷大舍入。 如果BigDecimal为正，则表现为ROUND_DOWN ; 如果为负，则表现为ROUND_UP 。 请注意，此舍入模式永远不会增加计算值。
        另请参见：
        常数字段值

      • ROUND_HALF_UP

        @Deprecated(since="9")
public static final int ROUND_HALF_UP
        Deprecated.
        Use RoundingMode.HALF_UP instead.
        舍入模式向“最近邻居”舍入，除非两个邻居等距，在这种情况下向上舍入。 如果丢弃的部分ROUND_UP则表现为ROUND_UP ; 否则，表现为ROUND_DOWN 。 请注意，这是我们大多数人在小学就读的舍入模式。
        另请参见：
        常数字段值

      • ROUND_HALF_DOWN

        @Deprecated(since="9")
public static final int ROUND_HALF_DOWN
        Deprecated.
        Use RoundingMode.HALF_DOWN instead.
        舍入模式向“最近邻居”舍入，除非两个邻居等距，在这种情况下向下舍入。 如果丢弃的部分> 0.5，则表现为ROUND_UP ; 否则，表现为ROUND_DOWN 。
        另请参见：
        常数字段值

      • ROUND_HALF_EVEN

        @Deprecated(since="9")
public static final int ROUND_HALF_EVEN
        Deprecated.
        Use RoundingMode.HALF_EVEN instead.
        舍入模式向“最近邻居”舍入，除非两个邻居等距，在这种情况下，向着偶邻居舍入。 如果丢弃的分数左边的数字是奇数，则表现为ROUND_HALF_UP ; 如果它是偶数，则表现为ROUND_HALF_DOWN 。 请注意，这是在一系列计算中重复应用时最小化累积误差的舍入模式。
        另请参见：
        常数字段值

      • ROUND_UNNECESSARY

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

    • 构造方法详细信息

      • BigDecimal

        public BigDecimal​(char[] in,
                  int offset,
                  int len)
        将 BigDecimal的字符数组表示转换为 BigDecimal ，接受与 BigDecimal(String)构造函数相同的字符序列，同时允许指定子数组。
        Implementation Note:
        如果字符序列中的字符序列已经可用，则使用此构造函数比将 char数组转换为字符串并使用 BigDecimal(String)构造函数 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)构造函数相同的字符序列，同时允许指定子数组并根据上下文设置进行舍入。
        Implementation Note:
        如果字符序列中的字符序列已经可用，则使用此构造函数比将 char数组转换为字符串并使用 BigDecimal(String)构造函数 BigDecimal(String) 。
        参数
        in - char作为字符来源的数组。
        offset - 要检查的数组中的第一个字符。
        len - 要考虑的字符数。
        mc - 要使用的上下文。
        异常
        ArithmeticException - 如果结果不准确但舍入模式为 UNNECESSARY 。
        NumberFormatException -如果 in不是的有效表示 BigDecimal或所定义的子阵列是不完全内 in 。
        从以下版本开始：
        1.5

      • BigDecimal

        public BigDecimal​(char[] in)
        将 BigDecimal的字符数组表示转换为 BigDecimal ，接受与 BigDecimal(String)构造函数相同的字符序列。
        Implementation Note:
        如果字符序列已经可用作字符数组，则使用此构造函数比将 char数组转换为字符串并使用 BigDecimal(String)构造函数 BigDecimal(String) 。
        参数
        in - char作为字符来源的数组。
        异常
        NumberFormatException -如果 in不是的有效表示 BigDecimal 。
        从以下版本开始：
        1.5

      • BigDecimal

        public BigDecimal​(char[] in,
                  MathContext mc)
        将 BigDecimal的字符数组表示转换为 BigDecimal ，接受与 BigDecimal(String)构造函数相同的字符序列，并根据上下文设置进行舍入。
        Implementation Note:
        如果字符序列已经可用作字符数组，则使用此构造函数比将 char数组转换为字符串并使用 BigDecimal(String)构造函数 BigDecimal(String) 。
        参数
        in - char作为字符来源的数组。
        mc - 要使用的上下文。
        异常
        ArithmeticException - 如果结果不准确但舍入模式为 UNNECESSARY 。
        NumberFormatException -如果 in不是的有效表示 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:
        Signopt Significand Exponentopt
        Sign:
        +
        -
        Significand:
        IntegerPart . FractionPartopt
        . FractionPart
        IntegerPart
        IntegerPart:
        Digits
        FractionPart:
        Digits
        Exponent:
        ExponentIndicator SignedInteger
        ExponentIndicator:
        e
        E
        SignedInteger:
        Signopt 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]
        API Note:
        对于float和double NaN和±Infinity以外的值，此构造函数与Float.toString(float)和Double.toString(double)返回的值兼容。 这通常是将float或double转换为BigDecimal的首选方法，因为它不会受到BigDecimal(double)构造函数的不可预测性的影响 。
        参数
        val - val字符串表示 BigDecimal 。
        异常
        NumberFormatException -如果 val不是的有效表示 BigDecimal 。

      • BigDecimal

        public BigDecimal​(String val,
                  MathContext mc)
        将 BigDecimal的字符串表示 BigDecimal转换为 BigDecimal ，接受与 BigDecimal(String)构造函数相同的字符串，并根据上下文设置进行舍入。
        参数
        val - val字符串表示 BigDecimal 。
        mc - 要使用的上下文。
        异常
        ArithmeticException - 如果结果不准确但舍入模式为 UNNECESSARY 。
        NumberFormatException - 如果 val不是BigDecimal的有效表示。
        从以下版本开始：
        1.5

      • BigDecimal

        public BigDecimal​(double val)
        将double转换为BigDecimal ，它是double的二进制浮点值的精确十进制表示形式。 返回的BigDecimal是最小值，使得(10scale × 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的比例是最小值，使得(10scale × val)是整数。

        这个构造函数的结果可能有些不可预测，一般不建议使用它。 请参阅BigDecimal(double)构造函数下的注释 。

        参数
        val - double要转换为 BigDecimal值。
        mc - 要使用的上下文。
        异常
        ArithmeticException - 如果结果不准确但RoundingMode不成功。
        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 - 如果结果不准确但舍入模式为 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 - int要转换为 BigDecimal值。
        从以下版本开始：
        1.5

      • BigDecimal

        public BigDecimal​(int val,
                  MathContext mc)
        将int转换为BigDecimal ，并根据上下文设置进行舍入。 在任何四舍五入之前， BigDecimal的比例为零。
        参数
        val - int要转换为 BigDecimal值。
        mc - 要使用的上下文。
        异常
        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 - 如果结果不准确但舍入模式为 UNNECESSARY 。
        从以下版本开始：
        1.5

    • 方法详细信息

      • valueOf

        public static BigDecimal valueOf​(long unscaledVal,
                                 int scale)
        将 long缩放值和 int比例转换为 BigDecimal 。
        API Note:
        优先提供给（此静态工厂法 long ， int ）构造，因为它允许使用频率重用 BigDecimal值。
        参数
        unscaledVal -的的非标度值 BigDecimal 。
        scale - 规模 BigDecimal 。
        结果
        a BigDecimal其值为 (unscaledVal × 10-scale) 。

      • valueOf

        public static BigDecimal valueOf​(long val)
        将 long值转换为 BigDecimal ，其标度为零。
        API Note:
        此静态工厂方法优先于（ long ）构造函数提供，因为它允许重用常用的 BigDecimal值。
        参数
        val -的价值 BigDecimal 。
        结果
        a BigDecimal其值为 val 。

      • valueOf

        public static BigDecimal valueOf​(double val)
        转换一个 double成 BigDecimal ，使用 double通过所提供的规范的字符串表示 Double.toString(double)方法。
        API Note:
        这通常是转换的首选方法 double （或 float ）成 BigDecimal ，作为返回的值等于从构建所得 BigDecimal使用的结果 Double.toString(double) 。
        参数
        val - double转换为 BigDecimal 。
        结果
        a 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 - 如果结果不准确但舍入模式为 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 ，必要时四舍五入。
        异常
        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)
        返回 BigDecimal其值为 (this × multiplicand) ，根据上下文设置进行舍入。
        参数
        multiplicand -价值被这个乘以 BigDecimal 。
        mc - 要使用的上下文。
        结果
        this * multiplicand ，必要时四舍五入。
        异常
        ArithmeticException - 如果结果不准确但舍入模式为 UNNECESSARY 。
        从以下版本开始：
        1.5

      • 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,
                         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 - divisor此 BigDecimal值。
        结果
        this / divisor
        异常
        ArithmeticException - 如果确切的商没有终止十进制扩展
        从以下版本开始：
        1.5

      • divide

        public BigDecimal divide​(BigDecimal divisor,
                         MathContext mc)
        返回 BigDecimal其值为 (this / divisor) ，根据上下文设置进行舍入。
        参数
        divisor - 此 BigDecimal分配值。
        mc - 要使用的上下文。
        结果
        this / divisor ，必要时四舍五入。
        异常
        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 ，必要时四舍五入。
        异常
        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,
                                       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)

      • sqrt

        public BigDecimal sqrt​(MathContext mc)
        返回this平方根的this并根据上下文设置进行舍入。

        返回结果的首选比例等于this.scale()/2 。 返回结果的值始终在所讨论精度的精确十进制值的一个ulp内。 如果舍入模式为HALF_UP ， HALF_DOWN ，或HALF_EVEN ，结果是二分之一精确十进制值的ulp内。

        特殊情况：

        • 数字上等于ZERO的数字的ZERO在数值上等于ZERO ，根据上述一般规则具有优选的标度。 特别是， ZERO ， ZERO.sqrt(mc).equals(ZERO)是任何真正MathContext作为参数。
        参数
        mc - 要使用的上下文。
        结果
        平方根 this 。
        异常
        ArithmeticException - 如果 this小于零。
        ArithmeticException - 如果请求了确切的结果（ mc.getPrecision()==0 ）并且没有确切结果的有限小数扩展
        ArithmeticException - 如果 (mc.getRoundingMode()==RoundingMode.UNNECESSARY ）并且确切的结果不能适合 mc.getPrecision()位数。
        从以下版本开始：
        9
        另请参见：
        BigInteger.sqrt()

      • pow

        public BigDecimal pow​(int n)
        返回BigDecimal其值为(thisn) ，精确计算功率，达到无限精度。

        参数n必须在0到999999999范围内，包括0和999999999。 ZERO.pow(0)返回ONE 。 请注意，将来的版本可能会扩展此方法的允许指数范围。

        参数
        n - 将此 BigDecimal至的权力。
        结果
        thisn
        异常
        ArithmeticException - 如果 n超出范围。
        从以下版本开始：
        1.5

      • pow

        public BigDecimal pow​(int n,
                      MathContext mc)
        返回BigDecimal其值为(thisn) 。 当前实现使用ANSI标准X3.274-1996中定义的核心算法，并根据上下文设置进行舍入。 通常，返回的数值在所选精度的精确数值的两个ulps范围内。 请注意，将来的版本可能会使用不同的算法，其允许的误差范围减小，允许的指数范围增加。

        X3.274-1996算法是：

        • 如果是，则抛出ArithmeticException异常
          • abs(n) > 999999999
          • mc.precision == 0和n < 0
          • mc.precision > 0和n具有超过mc.precision十进制数字
        • 如果n为零，即使n为零， 也会返回this ，否则
          • 如果n为正，则通过重复平方技术将结果计算到单个累加器中。 与蓄能器的各个乘法中使用相同的数学上下文设置为mc除了一个精度提高到mc.precision + elength + 1其中elength是十进制数字的数量n 。
          • 如果n为负数，则计算结果，好像n为正数; 然后使用上面指定的工作精度将该值分成一个。
          • 然后将正面或负面情况的最终值四舍五入到目标精度。
        参数
        n - 将此 BigDecimal提高到的 BigDecimal 。
        mc - 要使用的上下文。
        结果
        thisn使用ANSI标准X3.274-1996算法
        异常
        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)
        返回 BigDecimal其值为 (-this) ，根据上下文设置进行舍入。
        参数
        mc - 要使用的上下文。
        结果
        -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)
        返回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的精度 。 （精度是未缩放值中的位数。）

        零值的精度为1。

        结果
        这款 BigDecimal的精度。
        从以下版本开始：
        1.5

      • unscaledValue

        public BigInteger unscaledValue()
        返回BigInteger其值是此的非标度值 BigDecimal 。 （计算(this * 10this.scale()) ）
        结果
        BigDecimal的未缩放值。
        从以下版本开始：
        1.2

      • round

        public BigDecimal round​(MathContext mc)
        返回BigDecimal根据四舍五入MathContext设置。 如果精度设置为0，则不进行舍入。

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

        参数
        mc - 要使用的上下文。
        结果
        a BigDecimal根据 MathContext设置进行四舍五入。
        异常
        ArithmeticException - 如果舍入模式为 UNNECESSARY且 BigDecimal操作需要舍入。
        从以下版本开始：
        1.5
        另请参见：
        plus(MathContext)

      • setScale

        public BigDecimal setScale​(int newScale,
                           RoundingMode roundingMode)
        返回BigDecimal其比例为指定值，其未缩放值通过将此BigDecimal值乘以或除以适当的10的幂来确定，以保持其总值。 如果通过操作减小比例，则必须将未缩放的值除以（而不是相乘），并且可以改变该值; 在这种情况下，指定的舍入模式应用于除法。
        API Note:
        由于BigDecimal对象是不可变的，因此调用此方法不会导致原始对象被修改，这与通常使用名为setX mutate字段X方法的惯例相反。 而是， setScale返回具有适当比例的对象; 返回的对象可能会或可能不会被新分配。
        参数
        newScale - 要返回的 BigDecimal值的比例。
        roundingMode - 要应用的舍入模式。
        结果
        a BigDecimal其比例为指定值，其未缩放值是通过将此 BigDecimal值乘以或除以适当的10的幂来确定，以维持其总值。
        异常
        ArithmeticException - 如果 roundingMode==UNNECESSARY和指定的缩放操作需要舍入。
        从以下版本开始：
        1.5
        另请参见：
        RoundingMode

      • setScale

        @Deprecated(since="9")
public BigDecimal setScale​(int newScale,
                           int roundingMode)
        Deprecated.
        The method setScale(int, RoundingMode) should be used in preference to this legacy method.
        返回BigDecimal其比例为指定值，其未缩放值通过将此BigDecimal值乘以或除以适当的10的幂来确定，以保持其总值。 如果通过操作减小比例，则必须将未缩放的值除以（而不是相乘），并且可以改变该值; 在这种情况下，指定的舍入模式应用于除法。
        API Note:
        由于BigDecimal对象是不可变的，因此调用此方法不会导致原始对象被修改，这与通常使用名为setX mutate字段X方法的惯例相反。 而是， setScale返回具有适当比例的对象; 返回的对象可能会或可能不会被新分配。
        参数
        newScale - 要返回的 BigDecimal值的比例。
        roundingMode - 要应用的舍入模式。
        结果
        a 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在其小数部分的末尾具有足够多的零（即，其整数值为10的因子）以允许重新缩放而不改变其值，则该调用也可用于减小比例。

        此方法返回与setScale的双参数版本相同的结果，但在调用者不相关的情况下保存指定舍入模式的麻烦。

        API Note:
        由于BigDecimal对象是不可变的，因此调用此方法不会导致原始对象被修改，这与通常使用名为setX mutate字段X方法的惯例相反。 而是， setScale返回具有适当比例的对象; 返回的对象可能会或可能不会被新分配。
        参数
        newScale - 要返回的 BigDecimal值的比例。
        结果
        a BigDecimal其范围是指定值，其未缩放值是通过将此 BigDecimal值乘以或除以适当的10的幂来确定的，以保持其整体值。
        异常
        ArithmeticException - 如果指定的缩放操作需要舍入。
        另请参见：
        setScale(int, int) ， setScale(int, RoundingMode)

      • movePointLeft

        public BigDecimal movePointLeft​(int n)
        返回一个BigDecimal ，相当于这个小数点向左移动n位置。 如果n为非负数，则该呼叫仅将n添加到比例。 如果n为负数，则该呼叫相当于movePointRight(-n) 。 此次BigDecimal返回的BigDecimal值为(this × 10-n) ，比例为max(this.scale()+n, 0) 。
        参数
        n - 向左移动小数点的位数。
        结果
        一个 BigDecimal ，相当于这个小数点 n位置。
        异常
        ArithmeticException - 如果规模溢出。

      • movePointRight

        public BigDecimal movePointRight​(int n)
        返回一个BigDecimal ，相当于这个小数点向右移动了n位置。 如果n为非负数，则该调用n比例中减去n 。 如果n为负数，则该调用等效于movePointLeft(-n) 。 此次BigDecimal返回的BigDecimal值为(this × 10n) ，比例为max(this.scale()-n, 0) 。
        参数
        n - 向右移动小数点的位置数。
        结果
        一个 BigDecimal相当于这一个小数点移动到右边的 n位置。
        异常
        ArithmeticException - 如果比例溢出。

      • scaleByPowerOfTen

        public BigDecimal scaleByPowerOfTen​(int n)
        返回其数值等于（ this * 10 n ）的BigDecimal。 结果的比例是(this.scale() - n) 。
        参数
        n - 十分之一的指数幂
        结果
        一个BigDecimal，其数值等于（ this * 10 n ）
        异常
        ArithmeticException - 如果比例超出32位整数的范围。
        从以下版本开始：
        1.5

      • stripTrailingZeros

        public BigDecimal stripTrailingZeros()
        返回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 。 通过此方法，两个值相等但具有不同比例（如2.0和2.00）的BigDecimal对象被视为相等。 对于六个布尔比较运算符（<，==，>，> =，！=，<=）中的每一个，优先考虑该方法。 建议执行这些比较的习惯用法是： (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()

      • hashCode

        public int hashCode()
        返回此BigDecimal的哈希码。 需要注意的是2个BigDecimal对象在数值上相同，但在不同的标度（如2.0和2.00）将通常不具有相同的散列码。
        重写：
        hashCode类 Object
        结果
        此 BigDecimal哈希码。
        另请参见：
        equals(Object)

      • toString

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

        BigDecimal标准规范字符串形式的创建方式如下所示：首先，使用字符'0'到'9'将BigDecimal的未缩放值的BigDecimal转换为BigDecimal字符串，不带前导零（除非是它的值为零，在这种情况下使用单个'0'字符）。

        接下来，计算调整后的指数 ; 这是否定的比例，加上未转换的非标定值中的字符数，减去一个。 也就是-scale+(ulength-1) ，其中ulength是十进制数字（其精度 ）中未缩放值的绝对值的长度。

        如果标度大于或等于零且调整后的指数大于或等于-6 ，则该数字将转换为字符形式，而不使用指数表示法。 在这种情况下，如果比例为零，则不添加小数点，如果比例为正，则将插入小数点，并使用比例指定小数点右侧的字符数。 '0'必要，将'0'字符添加到转换后的非缩放值的左侧。 如果在插入后没有字符位于小数点之前， '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而具有唯一的字符串表示toString 。 如果该字符串表示转换回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的字符串表示形式。

        返回表示一个字符串BigDecimal如在所描述的toString()方法，不同之处在于，如果使用指数表示法，10的功率被调整为3（工程符号）的倍数，使得非零值的整数部分将在范围1到999.如果指数表示法用于零值，则使用小数点和一个或两个小数零位数，以便保留零值的比例。 注意，与输出toString() ，这种方法的输出是不能保证恢复相同[整数，标度]对本的BigDecimal如果输出串转换回一BigDecimal使用string constructor 。 此方法的结果满足较弱的约束，即通过将字符串构造函数应用于方法的输出，始终产生数值相等的结果。

        结果
        如果需要指数，则使用工程符号表示此 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 。 此转换类似于从基本收缩转换 double到long如The Java™ Language Specification定义：此的任何小数部分BigDecimal将被丢弃。 请注意，此转换可能会丢失有关BigDecimal值精度的信息。

        要在转换不精确时抛出异常（换句话说，如果丢弃非零小数部分），请使用toBigIntegerExact()方法。

        结果
        这个 BigDecimal转换为 BigInteger 。
        See The Java™ Language Specification:
        5.1.3缩小原始转换

      • 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定义：此的任何小数部分BigDecimal将被丢弃，并且如果产生的“ BigInteger ”太大而不适合在一个long ，仅低阶64返回位。 请注意，此转换可能会丢失有关此BigDecimal值的总体幅度和精度的信息，并返回具有相反符号的结果。
        Specified by:
        longValue在类 Number
        结果
        将 BigDecimal兑换成 long 。
        See The Java™ Language Specification:
        5.1.3缩小原始转换

      • longValueExact

        public long longValueExact()
        将BigDecimal转换为long ，检查是否丢失了信息。 如果此BigDecimal具有非零小数部分或超出long结果的可能范围，则抛出ArithmeticException 。
        结果
        BigDecimal转换为 long 。
        异常
        ArithmeticException - 如果 this具有非零小数部分，或者不适合 long 。
        从以下版本开始：
        1.5

      • intValue

        public int intValue()
        将BigDecimal转换为int 。 此转换类似于从基本收缩转换 double到short如The Java™ Language Specification定义：此的任何小数部分BigDecimal将被丢弃，并且如果产生的“ BigInteger ”太大而不适合用int ，只有低32返回位。 请注意，此转换可能会丢失有关此BigDecimal值的总体幅度和精度的信息，并返回具有相反符号的结果。
        Specified by:
        intValue ，类 Number
        结果
        BigDecimal转换为 int 。
        See The Java™ Language Specification:
        5.1.3缩小原始转换

      • intValueExact

        public int intValueExact()
        将BigDecimal转换为int ，检查是否丢失了信息。 如果此BigDecimal具有非零小数部分或超出int结果的可能范围，则抛出ArithmeticException 。
        结果
        BigDecimal转换为 int 。
        异常
        ArithmeticException - 如果 this具有非零小数部分，或者不适合 int 。
        从以下版本开始：
        1.5

      • shortValueExact

        public short shortValueExact()
        将此BigDecimal转换为short ，检查是否丢失了信息。 如果此BigDecimal具有非零小数部分或超出short结果的可能范围，则抛出ArithmeticException 。
        结果
        这个 BigDecimal转换为 short 。
        异常
        ArithmeticException - 如果 this具有非零小数部分，或者不适合 short 。
        从以下版本开始：
        1.5

      • byteValueExact

        public byte byteValueExact()
        将BigDecimal转换为byte ，检查是否丢失了信息。 如果此BigDecimal具有非零小数部分或超出byte结果的可能范围，则抛出ArithmeticException 。
        结果
        这个 BigDecimal转换为 byte 。
        异常
        ArithmeticException - 如果 this具有非零小数部分，或者不适合 byte 。
        从以下版本开始：
        1.5

      • floatValue

        public float floatValue()
        将BigDecimal转换为float 。 这种转换是类似于从基本收缩转换 double到float如The Java™ Language Specification定义：如果此BigDecimal有太大的幅度来表示作为float ，它会被转换为Float.NEGATIVE_INFINITY或Float.POSITIVE_INFINITY适当。 请注意，即使返回值是有限的，此转换也可能会丢失有关BigDecimal值精度的信息。
        Specified by:
        floatValue在类 Number
        结果
        这个 BigDecimal转换为 float 。
        See The Java™ Language Specification:
        5.1.3缩小原始转换

      • doubleValue

        public double doubleValue()
        将BigDecimal转换为double 。 这种转换是类似于从基本收缩转换 double到float如The Java™ Language Specification定义：如果此BigDecimal有太大的幅度表示为double ，它会被转换为Double.NEGATIVE_INFINITY或Double.POSITIVE_INFINITY适当。 请注意，即使返回值是有限的，此转换也可能会丢失有关BigDecimal值精度的信息。
        Specified by:
        doubleValue在类 Number
        结果
        这个 BigDecimal转换为 double 。
        See The Java™ Language Specification:
        5.1.3缩小原始转换

      • ulp

        public BigDecimal ulp()
        返回此BigDecimal的ulp（最后一个单位）的BigDecimal 。 非零BigDecimal值的ulp是该值与BigDecimal值之间的正距离，该值接着在数量上具有相同的位数。 零值的ulp在数值上等于1，比例为this 。 结果以与this相同的比例存储，因此零和非零值的结果等于[1, this.scale()] 。
        结果
        ulp的大小 this
        从以下版本开始：
        1.5