Module java.base
Package java.math

Class BigInteger

java.lang.Object
java.lang.Number
java.math.BigInteger
所有已实现的接口:
Serializable, Comparable<BigInteger>
public class BigInteger extends Number implements Comparable<BigInteger>
不可变的任意精度整数。所有操作的行为都好像BigIntegers是用二进制补码表示（类似于Java的原始整数类型）。BigInteger提供了所有Java的原始整数运算符的类比，以及java.lang.Math中的所有相关方法。此外，BigInteger提供了模运算、最大公约数计算、素性测试、素数生成、位操作以及其他一些杂项操作。

算术操作的语义与Java的整数算术运算符完全相同，如《Java语言规范》中所定义。例如，除以零会抛出一个ArithmeticException，负数除以正数会产生一个负（或零）余数。

移位操作的语义扩展了Java的移位运算符，允许负的移位距离。负移位距离的右移结果为左移，反之亦然。无符号右移操作符（>>>）被省略，因为此操作仅对于固定大小的字有意义，而不适用于概念上具有无限数量的前导虚拟符号位的表示。

按位逻辑操作的语义与Java的按位整数运算符完全相同。二进制运算符（and、or、xor）在执行操作之前隐式地对两个操作数中较短的操作数进行符号扩展。

比较操作执行有符号整数比较，类似于Java的关系和相等运算符执行的比较。

提供模运算操作以计算余数、执行指数运算和计算乘法逆元。这些方法始终返回一个非负结果，介于0和(modulus - 1)之间，包括这两个值。

位操作作用于操作数的二进制补码表示的单个位。必要时，操作数会进行符号扩展，以便包含指定的位。所有单比特操作都不会产生与被操作的BigInteger具有不同符号的BigInteger，因为它们只影响单个位，并且此类提供的任意大的抽象确保在每个BigInteger之前概念上有无限多个“虚拟符号位”。

为了简洁和清晰起见，在BigInteger方法的描述中始终使用伪代码。伪代码表达式(i + j)是“一个BigInteger，其值为BigInteger i和BigInteger j的值之和”的简写。伪代码表达式(i == j)是“如果且仅当BigInteger i表示与BigInteger j相同的值时为true”的简写。其他伪代码表达式类似地解释。

此类中的所有方法和构造函数在为任何输入参数传递空对象引用时都会抛出NullPointerException。BigInteger必须支持范围在-2Integer.MAX_VALUE（不包括）到+2Integer.MAX_VALUE（不包括）之间的值，并且可能支持超出该范围的值。当BigInteger构造函数或方法生成超出支持范围的值时，会抛出ArithmeticException。可能质数值的范围是有限的，可能小于BigInteger的完全支持的正范围。该范围必须至少为1到2500000000。

实现注意事项:
在参考实现中，当BigInteger构造函数和操作的结果超出支持范围-2Integer.MAX_VALUE（不包括）到+2Integer.MAX_VALUE（不包括）时，会抛出ArithmeticException。
参见Java语言规范:
4.2.2 整数操作
自版本:
1.1
另请参阅:

  • Field Details

    • ZERO

      public static final BigInteger ZERO
      BigInteger常量zero。
      自版本:
      1.2

    • ONE

      public static final BigInteger ONE
      BigInteger常量one。
      自版本:
      1.2

    • TWO

      public static final BigInteger TWO
      BigInteger常量two。
      自从:
      9

    • TEN

      public static final BigInteger TEN
      BigInteger 常量十。
      自从:
      1.5

  • Constructor Details

    • BigInteger

      public BigInteger(byte[] val, int off, int len)
      将包含 BigInteger 的二进制补码表示的字节数组子数组转换为 BigInteger。通过数组中的偏移量和长度指定子数组。假定子数组按 大端序 字节顺序排列：最重要的字节是索引为 off 的元素。在构造函数调用期间，假定 val 数组保持不变。如果数组 val 的长度非零且 off 为负数、len 为负数或 off+len 大于 val 的长度，则会抛出 IndexOutOfBoundsException。
      参数:
      val - 包含 BigInteger 二进制补码表示的子数组的字节数组。
      off - 二进制表示的起始偏移量。
      len - 要使用的字节数。
      抛出:
      NumberFormatException - val 的长度为零字节。
      IndexOutOfBoundsException - 如果提供的数组偏移量和长度会导致对字节数组的索引为负数或大于或等于数组长度。
      自从:
      9

    • BigInteger

      public BigInteger(byte[] val)
      将包含 BigInteger 的二进制补码表示的字节数组转换为 BigInteger。假定输入数组按 大端序 字节顺序排列：最重要的字节在第一个元素中。在构造函数调用期间，假定 val 数组保持不变。
      参数:
      val - BigInteger 的大端二进制补码表示。
      抛出:
      NumberFormatException - val 的长度为零字节。

    • BigInteger

      public BigInteger(int signum, byte[] magnitude, int off, int len)
      将 BigInteger 的符号-幅度表示转换为 BigInteger。符号表示为整数符号值：负数为 -1，零为 0，正数为 1。幅度是字节数组的子数组，按 大端序 字节顺序排列：最重要的字节是索引为 off 的元素。长度 len 的零值是允许的，并且将导致 BigInteger 值为 0，无论符号是 -1、0 还是 1。在构造函数调用期间，假定 magnitude 数组保持不变。如果数组 magnitude 的长度非零且 off 为负数、len 为负数或 off+len 大于 magnitude 的长度，则会抛出 IndexOutOfBoundsException。
      参数:
      signum - 数字的符号（负数为 -1，零为 0，正数为 1）。
      magnitude - 数字幅度的大端二进制表示。
      off - 二进制表示的起始偏移量。
      len - 要使用的字节数。
      抛出:
      NumberFormatException - signum 不是三个合法值之一（-1、0 和 1），或者 signum 为 0 且 magnitude 包含一个或多个非零字节。
      IndexOutOfBoundsException - 如果提供的数组偏移量和长度会导致对字节数组的索引为负数或大于或等于数组长度。
      自从:
      9

    • BigInteger

      public BigInteger(int signum, byte[] magnitude)
      将 BigInteger 的符号-幅度表示转换为 BigInteger。符号表示为整数符号值：负数为 -1，零为 0，正数为 1。幅度是字节数组的大端二进制表示：最重要的字节是第一个元素。长度为零的幅度数组是允许的，并且将导致 BigInteger 值为 0，无论符号是 -1、0 还是 1。在构造函数调用期间，假定 magnitude 数组保持不变。
      参数:
      signum - 数字的符号（负数为 -1，零为 0，正数为 1）。
      magnitude - 数字幅度的大端二进制表示。
      抛出:
      NumberFormatException - signum 不是三个合法值之一（-1、0 和 1），或者 signum 为 0 且 magnitude 包含一个或多个非零字节。

    • BigInteger

      public BigInteger(String val, int radix)
      将指定基数中的 BigInteger 的字符串表示转换为 BigInteger。字符串表示由可选的减号或加号后跟指定基数中的一个或多个数字序列组成。字符到数字的映射由 Character.digit 提供。字符串不能包含任何多余字符（例如空格）。
      参数:
      val - BigInteger 的字符串表示。
      radix - 用于解释 val 的基数。
      抛出:
      NumberFormatException - val 不是指定基数中 BigInteger 的有效表示，或者 radix 超出从 Character.MIN_RADIX 到 Character.MAX_RADIX 的范围，包括边界值。

    • BigInteger

      public BigInteger(String val)
      将十进制字符串表示的 BigInteger 转换为 BigInteger。字符串表示由可选的减号或加号后跟一个或多个十进制数字序列组成。字符到数字的映射由 Character.digit 提供。字符串不能包含任何多余字符（例如空格）。
      参数:
      val - 十进制字符串表示的 BigInteger。
      抛出:
      NumberFormatException - val 不是 BigInteger 的有效表示。

    • BigInteger

      public BigInteger(int numBits, Random rnd)
      构造一个随机生成的 BigInteger，均匀分布在 0 到 (2numBits - 1) 的范围内。分布的均匀性假定提供了一个公平的随机比特源在 rnd 中。请注意，此构造函数始终构造一个非负的 BigInteger。
      参数:
      numBits - 新 BigInteger 的最大位长度。
      rnd - 用于计算新 BigInteger 的随机性源。
      抛出:
      IllegalArgumentException - numBits 为负数。
      参见:

    • BigInteger

      public BigInteger(int bitLength, int certainty, Random rnd)
      构造一个随机生成的正 BigInteger，该 BigInteger 可能是素数，并具有指定的位长度。
      API 注意:
      建议优先使用 probablePrime 方法，除非有必须指定确定性的迫切需要。
      参数:
      bitLength - 返回的 BigInteger 的位长度。
      certainty - 表示调用方愿意容忍的不确定性的度量。新 BigInteger 表示素数的概率将超过 (1 - 1/2certainty)。此构造函数的执行时间与此参数的值成正比。
      rnd - 用于选择要测试素性的候选数的随机比特源。
      抛出:
      ArithmeticException - bitLength < 2 或 bitLength 太大。
      参见:

  • Method Details

    • probablePrime

      public static BigInteger probablePrime(int bitLength, Random rnd)
      返回一个可能是素数的正 BigInteger，具有指定的位长度。通过此方法返回的 BigInteger 是合数的概率不超过 2-100。
      参数:
      bitLength - 返回的 BigInteger 的位长度。
      rnd - 用于选择要测试素性的候选数的随机比特源。
      返回:
      一个具有 bitLength 位的可能是素数的 BigInteger
      抛出:
      ArithmeticException - bitLength < 2 或 bitLength 太大。
      自从:
      1.4
      参见:

    • nextProbablePrime

      public BigInteger nextProbablePrime()
      返回大于此 BigInteger 的第一个可能是素数的整数。通过此方法返回的数字是合数的概率不超过 2-100。在搜索时，此方法永远不会跳过素数：如果返回 p，则不存在素数 q，使得 this < q < p。
      实现注意:
      由于底层算法的性质，取决于 this 的大小，此方法可能会消耗大量内存，直至耗尽可用堆空间，或者可能运行很长时间。
      返回:
      大于此 BigInteger 的第一个可能是素数的整数。
      抛出:
      ArithmeticException - this < 0 或 this 太大。
      自从:
      1.5

    • valueOf

      public static BigInteger valueOf(long val)
      返回一个值等于指定 long 的 BigInteger。
      API注释:
      提供此静态工厂方法是为了优先于使用（long）构造函数，因为它允许重复使用频繁使用的BigIntegers。
      参数:
      val - 要返回的BigInteger的值。
      返回:
      具有指定值的BigInteger。

    • add

      public BigInteger add(BigInteger val)
      返回一个值为(this + val)的BigInteger。
      参数:
      val - 要添加到此BigInteger的值。
      返回:
      this + val

    • subtract

      public BigInteger subtract(BigInteger val)
      返回一个值为(this - val)的BigInteger。
      参数:
      val - 要从此BigInteger中减去的值。
      返回:
      this - val

    • multiply

      public BigInteger multiply(BigInteger val)
      返回一个值为(this * val)的BigInteger。
      实现注释:
      当val == this时，实现可能提供更好的算法性能。
      参数:
      val - 要乘以此BigInteger的值。
      返回:
      this * val

    • parallelMultiply

      public BigInteger parallelMultiply(BigInteger val)
      返回一个值为(this * val)的BigInteger。当this和val都很大时，通常在数千位上，可能会使用并行乘法。此方法返回与multiply(java.math.BigInteger)完全相同的数学结果。
      实现注释:
      当val == this时，此实现可能提供更好的算法性能。与multiply(java.math.BigInteger)相比，实现的并行乘法算法通常会使用更多的CPU资源以更快地计算结果，并且可能会稍微增加内存消耗。
      参数:
      val - 要乘以此BigInteger的值。
      返回:
      this * val
      自:
      19
      另请参阅:

    • divide

      public BigInteger divide(BigInteger val)
      返回一个值为(this / val)的BigInteger。
      参数:
      val - 用于除法的值。
      返回:
      this / val
      抛出:
      ArithmeticException - 如果val为零。

    • divideAndRemainder

      public BigInteger[] divideAndRemainder(BigInteger val)
      返回包含(this / val)和(this % val)的两个BigIntegers的数组。
      参数:
      val - 用于除法和计算余数的值。
      返回:
      两个BigIntegers的数组：商(this / val)是初始元素，余数(this % val)是最终元素。
      抛出:
      ArithmeticException - 如果val为零。

    • remainder

      public BigInteger remainder(BigInteger val)
      返回一个值为(this % val)的BigInteger。
      参数:
      val - 用于除法和计算余数的值。
      返回:
      this % val
      抛出:
      ArithmeticException - 如果val为零。

    • pow

      public BigInteger pow(int exponent)
      返回一个值为(thisexponent)的BigInteger。请注意，exponent是一个整数，而不是一个BigInteger。
      参数:
      exponent - 要将此BigInteger提升到的指数。
      返回:
      thisexponent
      抛出:
      ArithmeticException - exponent为负数。（这将导致操作产生非整数值。）

    • sqrt

      public BigInteger sqrt()
      返回此BigInteger的整数平方根。相应数学整数n的整数平方根是最大的数学整数s，使得s*s <= n。它等于floor(sqrt(n))的值，其中sqrt(n)表示将n视为实数时的实平方根。请注意，如果后者不能表示为整数值，则整数平方根将小于实数平方根。
      返回:
      this的整数平方根
      抛出:
      ArithmeticException - 如果this为负数。（负整数val的平方根为(i * sqrt(-val))，其中i是虚数单位，等于sqrt(-1)。）
      自:
      9

    • sqrtAndRemainder

      public BigInteger[] sqrtAndRemainder()
      返回一个包含this的整数平方根s和其余数this - s*s的两个BigIntegers的数组。
      返回:
      一个包含整数平方根在偏移量0处和余数在偏移量1处的两个BigIntegers的数组
      抛出:
      ArithmeticException - 如果this为负数。（负整数val的平方根为(i * sqrt(-val))，其中i是虚数单位，等于sqrt(-1)。）
      自:
      9
      另请参阅:

    • gcd

      public BigInteger gcd(BigInteger val)
      返回一个值为abs(this)和abs(val)的最大公约数的BigInteger。如果this == 0 && val == 0，则返回0。
      参数:
      val - 要计算最大公约数的值。
      返回:
      GCD(abs(this), abs(val))

    • abs

      public BigInteger abs()
      返回一个值为此BigInteger的绝对值的BigInteger。
      返回:
      abs(this)

    • negate

      public BigInteger negate()
      返回一个值为(-this)的BigInteger。
      返回:
      -this

    • signum

      public int signum()
      返回此BigInteger的signum函数。
      返回:
      如果此BigInteger的值为负数，则返回-1；如果为零，则返回0；如果为正数，则返回1。

    • mod

      public BigInteger mod(BigInteger m)
      返回一个值为(this mod m)的BigInteger。此方法与remainder不同之处在于它始终返回一个非负的BigInteger。
      参数:
      m - 模数。
      返回:
      this mod m
      抛出:
      ArithmeticException - m ≤ 0
      另请参阅:

    • modPow

      public BigInteger modPow(BigInteger exponent, BigInteger m)
      返回一个值为(thisexponent mod m)的BigInteger。 （与pow不同，此方法允许负指数。）
      参数:
      exponent - 指数。
      m - 模数。
      返回:
      thisexponent mod m
      抛出:
      ArithmeticException - m ≤ 0或指数为负数且此BigInteger与m不是相对质数。
      另请参阅:

    • modInverse

      public BigInteger modInverse(BigInteger m)
      返回一个值为(this-1 mod m)的BigInteger。
      参数:
      m - 模数。
      返回:
      this-1 mod m。
      抛出:
      ArithmeticException - m ≤ 0，或此BigInteger在模m下没有乘法逆元（即，此BigInteger与m不是相对质数）。

    • shiftLeft

      public BigInteger shiftLeft(int n)
      返回一个值为(this << n)的BigInteger。移位距离n可能为负数，在这种情况下，此方法执行右移。（计算floor(this * 2n)。）
      参数:
      n - 位移距离。
      返回:
      this << n
      另请参阅:

    • shiftRight

      public BigInteger shiftRight(int n)
      返回一个值为(this >> n)的BigInteger。执行符号扩展。移位距离n可能为负数，在这种情况下，此方法执行左移。（计算floor(this / 2n)。）
      参数:
      n - 位移距离。
      返回:
      this >> n
      另请参阅:

    • and

      public BigInteger and(BigInteger val)
      返回一个值为(this & val)的BigInteger。 （仅当此和val都为负数时，此方法才返回负BigInteger。）
      参数:
      val - 与此BigInteger进行AND运算的值。
      返回:
      this & val

    • or

      public BigInteger or(BigInteger val)
      返回一个值为(this | val)的BigInteger。 （仅当此或val为负数时，此方法才返回负BigInteger。）
      参数:
      val - 与此BigInteger进行OR运算的值。
      返回:
      this | val

    • xor

      public BigInteger xor(BigInteger val)
      返回一个BigInteger，其值为(this ^ val)。 （如果this和val中仅有一个为负，则此方法返回一个负的BigInteger。）
      参数:
      val - 与此BigInteger进行异或运算的值。
      返回:
      this ^ val

    • not

      public BigInteger not()
      返回一个BigInteger，其值为(~this)。 （如果此BigInteger为非负，则此方法返回一个负值。）
      返回:
      ~this

    • andNot

      public BigInteger andNot(BigInteger val)
      返回一个BigInteger，其值为(this & ~val)。 此方法相当于and(val.not())，为掩码操作提供了便利。 （如果this为负且val为正，则此方法返回一个负的BigInteger。）
      参数:
      val - 要进行补码和与操作的值。
      返回:
      this & ~val

    • testBit

      public boolean testBit(int n)
      如果指定位被设置，则返回true。 （计算((this & (1<<n)) != 0)。）
      参数:
      n - 要测试的位的索引。
      返回:
      如果指定位被设置，则返回true。
      抛出:
      ArithmeticException - n为负数。

    • setBit

      public BigInteger setBit(int n)
      返回一个BigInteger，其值等同于此BigInteger并设置了指定位。 （计算(this | (1<<n))。）
      参数:
      n - 要设置的位的索引。
      返回:
      this | (1<<n)
      抛出:
      ArithmeticException - n为负数。

    • clearBit

      public BigInteger clearBit(int n)
      返回一个BigInteger，其值等同于此BigInteger并清除了指定位。 （计算(this & ~(1<<n))。）
      参数:
      n - 要清除的位的索引。
      返回:
      this & ~(1<<n)
      抛出:
      ArithmeticException - n为负数。

    • flipBit

      public BigInteger flipBit(int n)
      返回一个BigInteger，其值等同于此BigInteger并翻转了指定位。 （计算(this ^ (1<<n))。）
      参数:
      n - 要翻转的位的索引。
      返回:
      this ^ (1<<n)
      抛出:
      ArithmeticException - n为负数。

    • getLowestSetBit

      public int getLowestSetBit()
      返回此BigInteger中最右边（最低位）的一个位的索引（最右边的一个位右侧的零位数）。 如果此BigInteger不包含任何一位，则返回-1。 （计算(this == 0? -1 : log2(this & -this))。）
      返回:
      此BigInteger中最右边的一个位的索引。

    • bitLength

      public int bitLength()
      返回此BigInteger的最小二进制补码表示中的位数，不包括符号位。 对于正BigIntegers，这等同于普通二进制表示中的位数。 对于零，此方法返回0。 （计算(ceil(log2(this < 0 ? -this : this+1)))。）
      返回:
      此BigInteger的最小二进制补码表示中的位数，不包括符号位。

    • bitCount

      public int bitCount()
      返回此BigInteger的二进制补码表示中与其符号位不同的位数。 在BigIntegers上实现位向量样式集时，此方法很有用。
      返回:
      此BigInteger的二进制补码表示中与其符号位不同的位数。

    • isProbablePrime

      public boolean isProbablePrime(int certainty)
      如果此BigInteger可能是素数，则返回true，如果它肯定是合数，则返回false。 如果certainty ≤ 0，则返回true。
      实现注意:
      由于底层素性测试算法的性质，根据this和certainty的大小，此方法可能会消耗大量内存，直至耗尽可用堆空间，或可能运行很长时间。
      参数:
      certainty - 表示调用者愿意容忍的不确定性的度量：如果调用返回true，则此BigInteger为素数的概率超过(1 - 1/2certainty)。此方法的执行时间与此参数的值成正比。
      返回:
      如果此BigInteger可能是素数，则返回true，如果它肯定是合数，则返回false。
      抛出:
      ArithmeticException - this太大。

    • compareTo

      public int compareTo(BigInteger val)
      将此BigInteger与指定的BigInteger进行比较。 为了执行这些比较，提供了此方法，而不是为六个布尔比较运算符(<, ==, >, >=, !=, <=)提供单独的方法。 执行这些比较的建议习惯用法是： (x.compareTo(y) <op> 0)，其中<op>是六个比较运算符之一。
      指定者:
      compareTo 在接口 Comparable<BigInteger>
      参数:
      val - 要将此BigInteger与之比较的BigInteger。
      返回:
      -1，0或1，表示此BigInteger在数值上小于、等于或大于val。

    • equals

      public boolean equals(Object x)
      将此BigInteger与指定的Object进行相等性比较。
      覆盖:
      equals 在类 Object
      参数:
      x - 要将此BigInteger与之比较的Object。
      返回:
      如果指定的Object是数值上等于此BigInteger的BigInteger，则返回true。
      参见:

    • min

      public BigInteger min(BigInteger val)
      返回此BigInteger和val的最小值。
      参数:
      val - 用于计算最小值的值。
      返回:
      其值为此BigInteger和val中较小者的BigInteger。如果它们相等，则可以返回任何一个。

    • max

      public BigInteger max(BigInteger val)
      返回此BigInteger和val的最大值。
      参数:
      val - 用于计算最大值的值。
      返回:
      其值为此BigInteger和val中较大者的BigInteger。如果它们相等，则可以返回任何一个。

    • hashCode

      public int hashCode()
      返回此BigInteger的哈希码。
      覆盖:
      hashCode 在类 Object
      返回:
      此BigInteger的哈希码。
      参见:

    • toString

      public String toString(int radix)
      返回此BigInteger在给定基数中的字符串表示。 如果基数超出从Character.MIN_RADIX到Character.MAX_RADIX的范围，它将默认为10（与Integer.toString的情况相同）。 使用Character.forDigit提供的数字到字符映射，并根据需要添加减号。 （此表示与(String, int)构造函数兼容。）
      参数:
      radix - 字符串表示中的基数。
      返回:
      在给定基数中的此BigInteger的字符串表示。
      参见:

    • toString

      public String toString()
      返回此BigInteger的十进制字符串表示。 使用Character.forDigit提供的数字到字符映射，并根据需要添加减号。 （此表示与(String)构造函数兼容，并允许与Java的+运算符进行字符串连接。）
      覆盖:
      toString 在类 Object
      返回:
      此BigInteger的十进制字符串表示。
      参见:

    • toByteArray

      public byte[] toByteArray()
      返回一个包含此 BigInteger 的二进制补码表示的字节数组。字节数组将按 大端序 字节顺序排列：最重要的字节位于第零个元素。数组将包含表示此 BigInteger 所需的最少字节数，包括至少一个符号位，即 (ceil((this.bitLength() + 1)/8))。（此表示与 (byte[]) 构造函数兼容。）
      返回：
      包含此 BigInteger 的二进制补码表示的字节数组。
      参见：

    • intValue

      public int intValue()
      将此 BigInteger 转换为一个 int。此转换类似于 Java 语言规范 中定义的从 long 到 int 的 缩小原始类型转换：如果此 BigInteger 太大而无法容纳在一个 int 中，则只返回低位的 32 位。请注意，此转换可能会丢失关于 BigInteger 值整体大小的信息，并返回一个带有相反符号的结果。
      指定者：
      intValue 在类 Number
      返回：
      将此 BigInteger 转换为一个 int。
      参见 Java 语言规范：
      5.1.3 缩小原始类型转换
      另请参见：

    • longValue

      public long longValue()
      将此 BigInteger 转换为一个 long。此转换类似于 Java 语言规范 中定义的从 long 到 int 的 缩小原始类型转换：如果此 BigInteger 太大而无法容纳在一个 long 中，则只返回低位的 64 位。请注意，此转换可能会丢失关于 BigInteger 值整体大小的信息，并返回一个带有相反符号的结果。
      指定者：
      longValue 在类 Number
      返回：
      将此 BigInteger 转换为一个 long。
      参见 Java 语言规范：
      5.1.3 缩小原始类型转换
      另请参见：

    • floatValue

      public float floatValue()
      将此 BigInteger 转换为一个 float。此转换类似于 Java 语言规范 中定义的从 double 到 float 的 缩小原始类型转换：如果此 BigInteger 的幅度太大而无法表示为一个 float，它将被转换为适当的 Float.NEGATIVE_INFINITY 或 Float.POSITIVE_INFINITY。请注意，即使返回值是有限的，此转换也可能会丢失关于 BigInteger 值精度的信息。
      指定者：
      floatValue 在类 Number
      返回：
      将此 BigInteger 转换为一个 float。
      参见 Java 语言规范：
      5.1.3 缩小原始类型转换

    • doubleValue

      public double doubleValue()
      将此 BigInteger 转换为一个 double。此转换类似于 Java 语言规范 中定义的从 double 到 float 的 缩小原始类型转换：如果此 BigInteger 的幅度太大而无法表示为一个 double，它将被转换为适当的 Double.NEGATIVE_INFINITY 或 Double.POSITIVE_INFINITY。请注意，即使返回值是有限的，此转换也可能会丢失关于 BigInteger 值精度的信息。
      指定者：
      doubleValue 在类 Number
      返回：
      将此 BigInteger 转换为一个 double。
      参见 Java 语言规范：
      5.1.3 缩小原始类型转换

    • longValueExact

      public long longValueExact()
      将此 BigInteger 转换为一个 long，检查是否丢失信息。如果此 BigInteger 的值超出了 long 类型的范围，则会抛出一个 ArithmeticException。
      返回：
      将此 BigInteger 转换为一个 long。
      抛出：
      ArithmeticException - 如果 this 的值无法完全适应一个 long。
      自：
      1.8
      另请参见：

    • intValueExact

      public int intValueExact()
      将此 BigInteger 转换为一个 int，检查是否丢失信息。如果此 BigInteger 的值超出了 int 类型的范围，则会抛出一个 ArithmeticException。
      返回：
      将此 BigInteger 转换为一个 int。
      抛出：
      ArithmeticException - 如果 this 的值无法完全适应一个 int。
      自：
      1.8
      另请参见：

    • shortValueExact

      public short shortValueExact()
      将此 BigInteger 转换为一个 short，检查是否丢失信息。如果此 BigInteger 的值超出了 short 类型的范围，则会抛出一个 ArithmeticException。
      返回：
      将此 BigInteger 转换为一个 short。
      抛出：
      ArithmeticException - 如果 this 的值无法完全适应一个 short。
      自：
      1.8
      另请参见：

    • byteValueExact

      public byte byteValueExact()
      将此 BigInteger 转换为一个 byte，检查是否丢失信息。如果此 BigInteger 的值超出了 byte 类型的范围，则会抛出一个 ArithmeticException。
      返回：
      将此 BigInteger 转换为一个 byte。
      抛出：
      ArithmeticException - 如果 this 的值无法完全适应一个 byte。
      自：
      1.8
      另请参见：