Module  java.base
软件包  java.math

Class BigDecimal

  • All Implemented Interfaces:
    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对象的算术方法也是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 ”。 类似地解释其他伪代码表达式。 方括号用于表示特定的BigInteger和缩放对定义BigDecimal值; 例如[ BigDecimal ]是BigDecimal数字等于0.19，具有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
        已过时。 改用RoundingMode.UP 。
        舍入模式从零开始。 始终在非零丢弃分数之前增加数字。 请注意，该舍入模式不会降低计算值的大小。
        另请参见：
        Constant Field Values

      • ROUND_DOWN

        @Deprecated(since="9")
public static final int ROUND_DOWN
        已过时。 改用RoundingMode.DOWN 。
        舍入模式向零舍入。 不要在丢弃的分数之前递增数字（即截断）。 请注意，该舍入模式不会增加计算值的大小。
        另请参见：
        Constant Field Values

      • ROUND_CEILING

        @Deprecated(since="9")
public static final int ROUND_CEILING
        已过时。 改用RoundingMode.CEILING 。
        圆形模式向正无穷大转弯。 如果BigDecimal为正，则表现为ROUND_UP ; 如果为负，表现为ROUND_DOWN 。 请注意，舍入模式不会降低计算值。
        另请参见：
        Constant Field Values

      • ROUND_FLOOR

        @Deprecated(since="9")
public static final int ROUND_FLOOR
        已过时。 改用RoundingMode.FLOOR 。
        舍入模式向负无穷大转弯。 如果BigDecimal为正，表现为ROUND_DOWN ; 如果为负，表现为ROUND_UP 。 请注意，舍入模式不会增加计算值。
        另请参见：
        Constant Field Values

      • ROUND_HALF_UP

        @Deprecated(since="9")
public static final int ROUND_HALF_UP
        已过时。 改用RoundingMode.HALF_UP 。
        四舍五入模式向“最近邻居”转弯，除非两个邻居都是等距的，在这种情况下是圆括弧的。 如果废弃分数为0.5‰，则为ROUND_UP ; 否则，表现为ROUND_DOWN 。 请注意，这是我们大多数人在小学教学的舍入模式。
        另请参见：
        Constant Field Values

      • ROUND_HALF_DOWN

        @Deprecated(since="9")
public static final int ROUND_HALF_DOWN
        已过时。 改用RoundingMode.HALF_DOWN 。
        四舍五入模式向“最近邻居”转弯，除非这两个邻居都是等距离的，在这种情况下，这是倒圆的。 如果废弃的分数> 0.5，则表示为ROUND_UP ; 否则，表现为ROUND_DOWN 。
        另请参见：
        Constant Field Values

      • ROUND_HALF_EVEN

        @Deprecated(since="9")
public static final int ROUND_HALF_EVEN
        已过时。 改用RoundingMode.HALF_EVEN 。
        四舍五入模式向“最近邻居”转弯，除非这两个邻居都是等距离的，在这种情况下，朝向偶数邻居。 行为为ROUND_HALF_UP如果丢弃的分数左边的数字是奇数的; 表现为ROUND_HALF_DOWN如果它是均匀的。 请注意，这是在一系列计算中重复应用时最小化累积误差的舍入模式。
        另请参见：
        Constant Field Values

      • ROUND_UNNECESSARY

        @Deprecated(since="9")
public static final int ROUND_UNNECESSARY
        已过时。 改用RoundingMode.UNNECESSARY 。
        舍入模式来确定所请求的操作具有精确的结果，因此不需要舍入。 如果在产生不精确结果的操作上指定了舍入模式，则抛出ArithmeticException 。
        另请参见：
        Constant Field Values

    • 构造方法详细信息

      • BigDecimal

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

      • BigDecimal

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

      • BigDecimal

        public BigDecimal​(char[] in,
                  MathContext mc)
        将 BigDecimal的字符阵列表示 BigDecimal转换为 BigDecimal ，接受与 BigDecimal(String)构造函数相同的字符序列，并根据上下文设置进行舍入。
        Implementation Note:
        如果字符序列已经可以作为字符数组使用，那么使用此构造函数的速度要快于将 char数组转换为字符串并使用 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 - 字符串表示形式 BigDecimal 。
        异常
        NumberFormatException -如果 val不是的有效表示 BigDecimal 。

      • BigDecimal

        public BigDecimal​(String val,
                  MathContext mc)
        将 BigDecimal的字符串表示 BigDecimal转换为 BigDecimal ，接受与 BigDecimal(String)构造函数相同的字符串，根据上下文设置进行舍入。
        参数
        val - 一个 BigDecimal字符串表示 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")创建一个完全等于0.1的BigDecimal ，如预期的那样。 因此，一般建议使用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是UNNECESSARY。
        NumberFormatException - 如果 val是无限或NaN。
        从以下版本开始：
        1.5

      • BigDecimal

        public BigDecimal​(BigInteger val)
        将BigInteger翻译成BigDecimal 。 BigDecimal的规模为零。
        参数
        val - BigInteger要转换为 BigDecimal值。

      • BigDecimal

        public BigDecimal​(BigInteger val,
                  MathContext mc)
        根据上下文设置将BigInteger转换为BigDecimal舍入。 BigDecimal的规模为零。
        参数
        val - BigInteger值转换为 BigDecimal 。
        mc - 要使用的上下文。
        异常
        ArithmeticException - 如果结果不正确，但舍入模式是 UNNECESSARY 。
        从以下版本开始：
        1.5

      • BigDecimal

        public BigDecimal​(BigInteger unscaledVal,
                  int scale)
        将BigInteger值和int标度转换为BigDecimal 。 BigDecimal值为(unscaledVal × 10-scale) 。
        参数
        unscaledVal - unscaledVal值 BigDecimal 。
        scale - 规模 BigDecimal 。

      • BigDecimal

        public BigDecimal​(BigInteger unscaledVal,
                  int scale,
                  MathContext mc)
        将BigInteger缩放值和int刻度转换为BigDecimal ，根据上下文设置进行舍入。 BigDecimal值为(unscaledVal × 10-scale) ，根据precision和舍入模式设置舍入。
        参数
        unscaledVal - unscaled value的 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 - unscaled value的 BigDecimal 。
        scale - 规模 BigDecimal 。
        结果
        一个 BigDecimal其值为 (unscaledVal × 10-scale) 。

      • valueOf

        public static BigDecimal valueOf​(long val)
        将 long值转换为 BigDecimal ，其大小为零。
        API Note:
        这种静态工厂方法优先于（ long ）构造函数，因为它允许重用常用的 BigDecimal值。
        参数
        val - 值 BigDecimal 。
        结果
        一个 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 。
        结果
        一个 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 - 这个 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()) 。 如果确切商的整数部分需要超过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)
        返回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的结果的二元素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（含）之间。 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中定义的核心算法，根据上下文设置进行舍入。 通常，返回的数值在所选精度的精确数值的两个ul内。 请注意，未来的版本可能会使用不同的算法，减少了允许的误差范围和增加的允许指数范围。

        X3.274-1996算法是：

        • 抛出一个ArithmeticException异常
          • abs(n) > 999999999
          • mc.precision == 0和n < 0
          • mc.precision > 0和n具有超过mc.precision十进制数字
        • 如果n为零， ONE返回即使this为零，否则
          • 如果n为正，则将结果通过重复的平方技术计算到单个累加器中。 与蓄能器的各个乘法中使用相同的数学上下文设置为mc除了一个精度提高到mc.precision + elength + 1其中elength是十进制数字的数量n 。
          • 如果n为负数，则计算结果为n为正数; 然后使用上述工作精度将该值分为一个。
          • 然后将正值或负数情况下的最终值四舍五入为目标精度。
        参数
        n - 提高这个 BigDecimal权力。
        mc - 要使用的上下文。
        结果
        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的比例表示未-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)
        根据MathContext设置返回一个BigDecimal 。 如果精度设置为0，则不进行舍入。

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

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

      • setScale

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

      • setScale

        @Deprecated(since="9")
public BigDecimal setScale​(int newScale,
                           int roundingMode)
        已过时。 应该优先使用方法setScale(int, RoundingMode)用于该传统方法。
        返回一个BigDecimal其尺度是指定值，其BigDecimal的值通过将该BigDecimal的非标度值乘以10的适当功率来确定，以维持其整体值。 如果通过操作缩小比例，则将非标定值除以（而不是乘以），并且该值可能会被更改; 在这种情况下，指定的舍入模式被应用于该划分。
        API Note:
        由于BigDecimal对象是不可变的，所以这种方法的调用不会导致原始对象被修改，这与通常使用命名为setX mutate字段X方法X 。 相反， setScale返回具有适当比例的对象; 返回的对象可能被新分配，也可能不会被新分配。
        参数
        newScale - 要返回的 BigDecimal值的比例。
        roundingMode - 要应用的舍入模式。
        结果
        一个 BigDecimal其规模是指定值，其非标度值通过将该 BigDecimal的非标度值乘以10的适当功率来确定，以维持其整体值。
        异常
        ArithmeticException - 如果是 roundingMode==ROUND_UNNECESSARY ，并且指定的缩放操作将需要四舍五入。
        IllegalArgumentException - 如果 roundingMode不表示有效的舍入模式。
        另请参见：
        ROUND_UP ， ROUND_DOWN ， ROUND_CEILING ， ROUND_FLOOR ， ROUND_HALF_UP ， ROUND_HALF_DOWN ， ROUND_HALF_EVEN ， ROUND_UNNECESSARY

      • setScale

        public BigDecimal setScale​(int newScale)
        返回一个BigDecimal其缩放比例是指定值，其值在数字上等于BigDecimal 。 抛出一个ArithmeticException如果这是不可能的。

        此调用通常用于增加比例，在这种情况下，可以确保存在指定比例的BigDecimal和正确的值。 如果呼叫者知道BigDecimal在其小数部分结尾处具有足够多的零（即，其整数值中的十个因子）以允许重新调整而不改变其值，那么该呼叫也可以用于减小比例。

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

        API Note:
        由于BigDecimal对象是不可变的，所以这种方法的调用不会导致原始对象被修改，这与通常使用名称为setX字段X 。 相反， setScale返回具有适当比例的对象; 返回的对象可能被新分配，也可能不会被新分配。
        参数
        newScale - 要退回的 BigDecimal值的比例。
        结果
        一个 BigDecimal其规模是指定值，其非标度值通过将该 BigDecimal的非标度值乘以10的适当功率来确定，以维持其整体值。
        异常
        ArithmeticException - 如果指定的缩放操作需要四舍五入。
        另请参见：
        setScale(int, int) ， setScale(int, RoundingMode)

      • movePointLeft

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

      • movePointRight

        public BigDecimal movePointRight​(int n)
        返回一个BigDecimal ，相当于这个小数点，移动了n地方。 如果n是非负数，则呼叫n比例中减去n 。 如果n为负，则该呼叫相当于movePointLeft(-n) 。 此呼叫返回的BigDecimal具有值(this × 10n)和规模max(this.scale()-n, 0) 。
        参数
        n - 将小数点向右移动的位数。
        结果
        一个 BigDecimal相当于这个与小数点的位置移动了 n地方。
        异常
        ArithmeticException - 如果比例溢出。

      • scaleByPowerOfTen

        public BigDecimal scaleByPowerOfTen​(int n)
        返回一个BigDecimal，其数值等于（ this * 10 n ）。 结果的比例为(this.scale() - n) 。
        参数
        n - 十个指数幂的比例
        结果
        其数值等于（ this * 10 n ）的BigDecimal
        异常
        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 。 两个BigDecimal对象的价值相等但具有不同的比例（如2.0和2.00）被认为是相等的这种方法。 该方法优先于六个布尔比较运算符（<，==，>，> =，！=，<=）中的每一个的各个方法。 用于执行这些比较的建议成语是： (x.compareTo(y) < op > 0) ，其中< op >是六个比较运算符之一。
        Specified by:
        compareTo在接口 Comparable<BigDecimal>
        参数
        val - BigDecimal要比较这个 BigDecimal 。
        结果
        -1,0或1，因为这个 BigDecimal在数字上小于，等于或大于 val 。

      • equals

        public boolean equals​(Object x)
        将此BigDecimal与指定的Object进行比较，以获得相等性。 与compareTo不同，该方法认为两个BigDecimal对象只有在值和比例相等时才相等（因此，当通过此方法比较时，2.0不等于2.00）。
        重写：
        equals在 Object
        参数
        x - Object到这个 BigDecimal被比较。
        结果
        true当且仅当指定的 Object是一个 BigDecimal其值和比例等于此 BigDecimal的。
        另请参见：
        compareTo(java.math.BigDecimal) ， hashCode()

      • min

        public BigDecimal min​(BigDecimal val)
        返回此 BigDecimal和 val 。
        参数
        val - 要计算最小值的值。
        结果
        在BigDecimal其值是此的较小BigDecimal和val 。 如果它们相同，则由compareTo方法定义，则返回this 。
        另请参见：
        compareTo(java.math.BigDecimal)

      • max

        public BigDecimal max​(BigDecimal val)
        返回此 BigDecimal和 val 。
        参数
        val - 要计算最大值的值。
        结果
        在BigDecimal其值是此的更大BigDecimal和val 。 如果它们相同，则由compareTo方法定义，则返回this 。
        另请参见：
        compareTo(java.math.BigDecimal)

      • hashCode

        public int hashCode​()
        返回此BigDecimal的哈希码。 请注意，两个BigDecimal对象在数字上相等但尺度不同（如2.0和2.00）通常不会有相同的哈希码。
        重写：
        hashCode在 Object
        结果
        这个 BigDecimal哈希码。
        另请参见：
        equals(Object)

      • toString

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

        通过以下步骤创建BigDecimal标准规范字符串形式：首先，使用'0'至'9'的字符，将BigDecimal值的BigDecimal转换为基数为10的字符串，不带前导零（除其值为零，在这种情况下使用单个'0'字符）。

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

        如果刻度大于或等于零，并且调整后的指数大于或等于-6 ，则该数字将转换为字符形式而不使用指数符号。 在这种情况下，如果刻度为零，则不加小数点，如果刻度为正，则将插入小数点，刻度指定小数点右侧的字符数。 '0'字符根据需要添加到转换的未缩放值的左侧。 如果在插入后没有字符在小数点之前，那么常规的'0'字符是前缀。

        否则（即，如果比例为负数，或调整后的指数小于-6 ），则该数字将使用指数符号转换为字符形式。 在这种情况下，如果转换后的BigInteger有多个数字，则在第一个数字后插入一个小数点。 然后，字符形式的指数后缀到转换的未缩放值（可能带有插入的小数点）; 这包括字母'E'紧随其后，被调整的指数转换为字符形式。 后者基于十进制，使用没有前导零的字符'0'至'9' ，如果调整的指数为负，则总是以符号字符'-' （ '\u002D' ）为前缀，否则为'+' （ '\u002B' ））。

        最后，如果未缩放的值小于零，则整个字符串的前缀为负号字符'-' （ '\u002D' ）。 如果未标定值为零或正数，则不会标记符号。

        例子：

        对于左侧的每个表示[未缩放值 ， 缩放 ]，生成的字符串显示在右侧。 

          [123,0]      "123"
 [-123,0]     "-123"
 [123,-1]     "1.23E+3"
 [123,-3]     "1.23E+5"
 [123,1]      "12.3"
 [123,5]      "0.00123"
 [123,10]     "1.23E-8"
 [-123,12]    "-1.23E-10"
        笔记：
        1. 可区分的BigDecimal值与此转换的结果之间存在一对一映射。 也就是说，作为使用toString的结果，每个可区分的BigDecimal值（未缩放的值和比例）具有唯一的字符串表示。 如果该字符串表示转换回BigDecimal使用BigDecimal(String)构造，则原始值将被回收。
        2. 给定数字产生的字符串总是相同的; 它不受区域设置的影响。 这意味着它可以用作交换十进制数据的标准字符串表示形式，也可以用作Hashtable等的键。区域设置敏感数字格式化和解析由NumberFormat类及其子类来处理。
        3. toEngineeringString()方法可用于以工程符号表示数字，并且setScale方法可用于舍入BigDecimal以便在小数点后具有已知数字的数字。
        4. 使用由Character.forDigit提供的数字到字符映射。
        重写：
        toString在 Object
        结果
        字符串表示的这个 BigDecimal 。
        另请参见：
        Character.forDigit(int, int) ， BigDecimal(java.lang.String)

      • toEngineeringString

        public String toEngineeringString​()
        返回此BigDecimal的字符串表示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具有负比例尺，则由该方法生成的字符串将在字符串构造函数处理时具有0的比例。 （该方法类似于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 。 非零的ulp BigDecimal值是该值和之间的正距离BigDecimal值下在幅度上具有相同数目的位数大。 零值的ulp在数值上等于1，刻度为this 。 结果存储的this与this相同，因此零和非零值的结果等于[1, this.scale()] 。
        结果
        尺寸为ulp的 this
        从以下版本开始：
        1.5