模块  java.base
软件包  java.math

Class BigDecimal

  • 实现的所有接口
    SerializableComparable<BigDecimal>

    public class BigDecimalextends Numberimplements 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

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

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

    对于所有算术运算符,执行操作就像首先计算精确的中间结果一样,然后使用选定的舍入模式舍入到精度设置(如果需要)指定的位数。 如果未返回确切结果,则丢弃确切结果的某些数字位置。 当舍入增加返回结果的幅度时,可以通过传播到前导“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/320.03125

    在舍入之前,逻辑确切中间结果的比例是该操作的首选比例。 如果精确的数值结果不能用precision数字表示,则舍入选择要返回的数字集,并将结果的比例从中间结果的比例减小到可以表示实际返回的precision数字的最小比例。 如果确切结果可以用最多precision数字表示,则返回具有最接近首选比例的比例的结果的表示。 特别地,通过去除尾随零并减小比例,可以用少于precision数字来表示精确表示的商。 例如,使用floor舍入模式舍入到三位数,
    19/100 = 0.19 // integer=19, scale=2

    21/110 = 0.190 // integer=190, scale=3

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

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

    提供了两种类型的操作来操纵BigDecimal比例:缩放/舍入操作和小数点运动操作。 缩放/舍入操作( setScaleround )返回BigDecimal其值大约(或精确)等于操作数的值,但其标度或精度是指定值; 也就是说,它们会增加或减少存储数字的精度,而对其值的影响最小。 小数点运动操作( movePointLeftmovePointRight )通过将小数点沿指定方向移动指定距离来返回从操作数创建的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不一致 ComparableSortedMapSortedSet获取更多信息。
    从以下版本开始:
    1.1
    另请参见:
    BigIntegerMathContextRoundingModeSortedMapSortedSetSerialized 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.
        舍入模式断言所请求的操作具有精确结果,因此不需要舍入。 如果在产生不精确结果的操作上指定了此舍入模式,则抛出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_VALUEInteger.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_VALUEInteger.MAX_VALUE之间。

        字符到数字的映射由Character.digit(char, int)提供,设置为转换为基数10.字符串可能不包含任何无关的字符(例如,空格)。

        例子:
        返回的BigDecimal值等于有效数和 10 指数 对于左边,将得到的表示中的每个串[ BigIntegerscale ]被示在右边。

          "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:
        对于floatdouble NaN和±Infinity以外的值,此构造函数与Float.toString(float)Double.toString(double)返回的值兼容。 这通常是将floatdouble转换为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 ,请注意,此构造提供了一个精确的转换; 它没有给出相同的结果转换doubleString使用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:
        优先提供给(此静态工厂法 longint )构造,因为它允许使用频率重用 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)
        转换一个 doubleBigDecimal ,使用 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.UNNECESSARYthis.scale()不足以完全表示除法的结果。
        从以下版本开始:
        1.5
      • divide

        public BigDecimal divide​(BigDecimal divisor)
        返回BigDecimal其值为(this / divisor) ,其首选比例为(this.scale() - divisor.scale()) ; 如果无法表示确切的商(因为它具有非终止的十进制扩展),则抛出ArithmeticException
        参数
        divisor - divisorBigDecimal值。
        结果
        this / divisor
        异常
        ArithmeticException - 如果确切的商没有终止十进制扩展
        从以下版本开始:
        1.5
      • divide

        public BigDecimal divide​(BigDecimal divisor,                         MathContext mc)
        返回 BigDecimal其值为 (this / divisor) ,根据上下文设置进行舍入。
        参数
        divisor - 此 BigDecimal分配值。
        mc - 要使用的上下文。
        结果
        this / divisor ,必要时四舍五入。
        异常
        ArithmeticException - 如果结果不准确但舍入模式为 UNNECESSARYmc.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上与根据上下文设置进行舍入计算出的两个操作数。

        请注意,如果需要整数商和余数,则此方法比分别使用divideToIntegralValueremainder方法更快,因为除法只需执行一次。

        参数
        divisor - 要分割此 BigDecimal值,并计算余数。
        mc - 要使用的上下文。
        结果
        两个元素 BigDecimal数组:商( divideToIntegralValue的结果)是初始元素,余数是最终元素。
        异常
        ArithmeticException - 如果是 divisor==0
        ArithmeticException - 如果结果不准确但舍入模式为 UNNECESSARYmc.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_UPHALF_DOWN ,或HALF_EVEN ,结果是二分之一精确十进制值的ulp内。

        特殊情况:

        • 数字上等于ZERO的数字的ZERO在数值上等于ZERO ,根据上述一般规则具有优选的标度。 特别是, ZEROZERO.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 == 0n < 0
          • mc.precision > 0n具有超过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 - 如果舍入模式为 UNNECESSARYBigDecimal操作需要舍入。
        从以下版本开始:
        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_UPROUND_DOWNROUND_CEILINGROUND_FLOORROUND_HALF_UPROUND_HALF_DOWNROUND_HALF_EVENROUND_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 ,它在数值上等于此值,但从表示中删除了任何尾随零。 例如,从汽提尾随零BigDecimal600.0 ,它有[ BigIntegerscale ]组件等于[6000,1],产率6E2与[ BigIntegerscale ]组分等于[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 - ObjectBigDecimal比较。
        结果
        true当且仅当指定的 ObjectBigDecimal其值和比例等于此 BigDecimal
        另请参见:
        compareTo(java.math.BigDecimal)hashCode()
      • hashCode

        public int hashCode()
        返回此BigDecimal的哈希码。 需要注意的是2个BigDecimal对象在数值上相同,但在不同的标度(如2.0和2.00)将通常具有相同的散列码。
        重写:
        hashCodeObject
        结果
        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 此转换类似于从基本收缩转换 doublelongThe 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 此转换类似于从基本收缩转换 doubleshortThe 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 此转换类似于从基本收缩转换 doubleshortThe 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 这种转换是类似于从基本收缩转换 doublefloatThe Java™ Language Specification定义:如果此BigDecimal有太大的幅度来表示作为float ,它会被转换为Float.NEGATIVE_INFINITYFloat.POSITIVE_INFINITY适当。 请注意,即使返回值是有限的,此转换也可能会丢失有关BigDecimal值精度的信息。
        Specified by:
        floatValue在类 Number
        结果
        这个 BigDecimal转换为 float
        See The Java™ Language Specification:
        5.1.3缩小原始转换
      • doubleValue

        public double doubleValue()
        BigDecimal转换为double 这种转换是类似于从基本收缩转换 doublefloatThe Java™ Language Specification定义:如果此BigDecimal有太大的幅度表示为double ,它会被转换为Double.NEGATIVE_INFINITYDouble.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