模块 java.base
包 java.math

类 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 还提供模运算、GCD 计算、素数测试、素数生成、位操作和其他一些杂项操作。

算术运算的语义完全模仿 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) 是“true 当且仅当 BigInteger i 表示与 BigInteger j 相同的值时的简写。”其他伪代码表达式的解释类似。

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

实现注意事项：
在参考实现中，BigInteger 构造函数和操作在结果超出支持的 -2 范围时抛出 ArithmeticExceptionInteger.MAX_VALUE （独占）至 +2Integer.MAX_VALUE （独家的）。
看Java 语言规范:
4.2.2 整数运算
自从：
1.1
参见：

  • 字段详细信息

    • ZERO

      public static final BigInteger  ZERO
      BigInteger 常数零。
      自从：
      1.2

    • ONE

      public static final BigInteger  ONE
      BigInteger 常量一。
      自从：
      1.2

    • TWO

      public static final BigInteger  TWO
      BigInteger 常量二。
      自从：
      9

    • TEN

      public static final BigInteger  TEN
      BigInteger 常量 10。
      自从：
      1.5

  • 构造方法详细信息

    • 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，无论 signum 是 -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 表示正数。幅度是一个字节数组大端字节顺序：最高有效字节是第零个元素。长度为零的幅度数组是允许的，并且无论 signum 是 -1、0 还是 1，都会导致 BigInteger 值为 0。假定 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 提供。 String 不能包含任何无关字符（例如空格）。
      参数：
      val - BigInteger 的字符串表示形式。
      radix - 用于解释 val 的基数。
      抛出：
      NumberFormatException - val 不是指定基数中 BigInteger 的有效表示，或者 radix 超出了从 Character.MIN_RADIX 到 Character.MAX_RADIX 的范围（含）。

    • BigInteger

      public BigInteger(String  val)
      将 BigInteger 的十进制字符串表示形式转换为 BigInteger。字符串表示形式包含一个可选的减号或加号，后跟一个或多个十进制数字序列。字符到数字的映射由 Character.digit 提供。 String 不能包含任何无关字符（例如空格）。
      参数：
      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，它可能是质数，具有指定的 bitLength。
      API 注意：
      建议优先使用 probablePrime 方法而不是此构造函数，除非迫切需要指定确定性。
      参数：
      bitLength - 返回的 BigInteger 的 bitLength。
      certainty - 衡量调用者愿意容忍的不确定性。新的 BigInteger 表示素数的概率将超过 (1 - 1/2certainty ).此构造方法的执行时间与此参数的值成正比。
      rnd - 用于选择要进行素性测试的候选者的随机位源。
      抛出：
      ArithmeticException - bitLength < 2 或 bitLength 太大。
      参见：

  • 方法详情

    • probablePrime

      public static BigInteger  probablePrime(int bitLength, Random  rnd)
      返回一个可能是质数的正 BigInteger，具有指定的 bitLength。该方法返回的一个BigInteger是合数的概率不超过2-100.
      参数：
      bitLength - 返回的 BigInteger 的 bitLength。
      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)
      返回一个 BigInteger，其值等于指定的 long 的值。
      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 - 此 BigInteger 要除以的值。
      返回：
      this / val
      抛出：
      ArithmeticException - 如果 val 为零。

    • divideAndRemainder

      public BigInteger [] divideAndRemainder(BigInteger  val)
      返回包含 (this / val) 后跟 (this % val) 的两个 BigInteger 的数组。
      参数：
      val - 此 BigInteger 要除以的值，并计算余数。
      返回：
      两个 BigInteger 的数组：商 (this / val) 是初始元素，余数 (this % val) 是最终元素。
      抛出：
      ArithmeticException - 如果 val 为零。

    • remainder

      public BigInteger  remainder(BigInteger  val)
      返回值为 (this % val) 的 BigInteger。
      参数：
      val - 此 BigInteger 要除以的值，并计算余数。
      返回：
      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 <= n 的最大数学整数 s。它等于 floor(sqrt(n)) 的值，其中 sqrt(n) 表示被视为实数的 n 的实数平方根。请注意，如果后者不能表示为整数值，则整数平方根将小于实数平方根。
      返回：
      this 的整数平方根
      抛出：
      ArithmeticException - 如果 this 为负。 （负整数 val 的平方根是 (i * sqrt(-val)) 其中i是个虚数单位并且等于 sqrt(-1) 。）
      自从：
      9

    • sqrtAndRemainder

      public BigInteger [] sqrtAndRemainder()
      返回两个 BigInteger 的数组，分别包含 this 的整数平方根 s 及其余数 this - s*s。
      返回：
      两个 BigInteger 的数组，整数平方根位于偏移量 0 处，余数位于偏移量 1 处
      抛出：
      ArithmeticException - 如果 this 为负。 （负整数 val 的平方根是 (i * sqrt(-val)) 其中i是个虚数单位并且等于 sqrt(-1) 。）
      自从：
      9
      参见：

    • gcd

      public BigInteger  gcd(BigInteger  val)
      返回一个 BigInteger，其值为 abs(this) 和 abs(val) 的最大公约数。如果 this == 0 && val == 0 则返回 0。
      参数：
      val - 用于计算 GCD 的值。
      返回：
      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 的符号函数。
      返回：
      -1、0 或 1，因为此 BigInteger 的值为负数、零或正数。

    • mod

      public BigInteger  mod(BigInteger  m)
      返回值为 (this mod m 的 BigInteger。此方法与 remainder 的不同之处在于它总是返回一个non-negative大整数。
      参数：
      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 的 BigInteger-1 mod m) .
      参数：
      m - 模数。
      返回：
      this -1 mod m .
      抛出：
      ArithmeticException - m ≤ 0，或者这个 BigInteger 没有 multiplicative inverse mod m（也就是说，这个 BigInteger 不是相对质数米）。

    • 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。 （当且仅当 this 和 val 均为负数时，此方法返回负数 BigInteger。）
      参数：
      val - 要与此 BigInteger 进行“与”运算的值。
      返回：
      this & val

    • or

      public BigInteger  or(BigInteger  val)
      返回值为 (this | val) 的 BigInteger。 （当且仅当 this 或 val 为负数时，此方法返回负数 BigInteger。）
      参数：
      val - 要与此 BigInteger 进行“或”运算的值。
      返回：
      this | val

    • xor

      public BigInteger  xor(BigInteger  val)
      返回值为 (this ^ val) 的 BigInteger。 （当且仅当 this 和 val 恰好有一个为负数时，此方法返回负数 BigInteger。）
      参数：
      val - 要与此 BigInteger 进行异或运算的值。
      返回：
      this ^ val

    • not

      public BigInteger  not()
      返回值为 (~this) 的 BigInteger。 （当且仅当此 BigInteger 为非负时，此方法才返回负值。）
      返回：
      ~this

    • andNot

      public BigInteger  andNot(BigInteger  val)
      返回值为 (this & ~val) 的 BigInteger。此方法等效于 and(val.not()) ，是为了方便屏蔽操作而提供的。 （当且仅当 this 为负且 val 为正时，此方法返回负 BigInteger。）
      参数：
      val - 要与此 BigInteger 进行补充和与运算的值。
      返回：
      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 的最小二进制补码表示中的位数，excluding 符号位。对于正 BigIntegers，这相当于普通二进制表示中的位数。对于零，此方法返回 0 。 （计算 (ceil(log2(this < 0 ? -this : this+1))) 。）
      返回：
      此 BigInteger 的最小二进制补码表示中的位数，excluding 符号位。

    • bitCount

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

    • isProbablePrime

      public boolean isProbablePrime(int certainty)
      如果此 BigInteger 可能是素数，则返回 true；如果它肯定是合数，则返回 false。如果 certainty ≤ 0，则返回 true。
      实现注意事项：
      由于底层素数测试算法的性质，并根据 this 和 certainty 的大小，此方法可能会消耗大量内存，直至耗尽可用堆空间，或者可能会运行很长时间。
      参数：
      certainty - 调用者愿意容忍的不确定性度量：如果调用返回 true，则此 BigInteger 为素数的概率超过 (1 - 1/2certainty ).该方法的执行时间与该参数的值成正比。
      返回：
      true 如果这个 BigInteger 可能是质数，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 要与之比较的对象。
      返回：
      true 当且仅当指定的对象是一个 BigInteger，其值在数值上等于此 BigInteger。
      参见：

    • min

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

    • max

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

    • 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 。这种转换类似于缩小原始转换从 long 到 int 如定义Java 语言规范：如果此 BigInteger 太大而无法放入 int 中，则仅返回低位 32 位。请注意，此转换可能会丢失有关 BigInteger 值的总体大小的信息，并返回带有相反符号的结果。
      指定者：
      intValue 在类 Number 中
      返回：
      这个 BigInteger 转换为 int 。
      看Java 语言规范:
      5.1.3 缩小原始转换
      参见：

    • longValue

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

    • floatValue

      public float floatValue()
      将此 BigInteger 转换为 float 。这种转换类似于缩小原始转换从 double 到 float 如定义Java 语言规范：如果此 BigInteger 的量级太大而无法表示为 float ，则会根据需要将其转换为 Float.NEGATIVE_INFINITY 或 Float.POSITIVE_INFINITY 。请注意，即使返回值是有限的，此转换也可能会丢失有关 BigInteger 值精度的信息。
      指定者：
      floatValue 在类 Number 中
      返回：
      这个 BigInteger 转换为 float 。
      看Java 语言规范:
      5.1.3 缩小原始转换

    • doubleValue

      public double doubleValue()
      将此 BigInteger 转换为 double 。这种转换类似于缩小原始转换从 double 到 float 如定义Java 语言规范：如果此 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
      参见：