JavaBigInteger超大整数计算方法

在 Ja va 日常开发中，int、long 这些基本整数类型都有固定的取值范围——上限一到，数值就会静悄悄地“溢出”，而且编译运行都不会给你任何提示。结果就是业务数据莫名其妙地出错，排查起来让人头大。

要解决超大整数运算，Ja va 提供了一个重量级武器：BigInteger 类，位于 ja va.math 包。它专门用来处理任意长度的超大整数，加减乘除、取模、幂运算、位运算、进制转换……几乎没有它搞不定的整数运算。在算法竞赛、金融统计、密码学、大数加密这些场景里，BigInteger 是绝对的核心类。

一、基本类型数值范围与溢出问题

一旦数值超过 long 的最大值，基本类型就彻底没辙了——溢出发生后，程序不会报错，但结果已经错了，而且错得悄无声息。

这时候，必须请出 BigInteger。

二、BigInteger 核心特点

1. 支持无限大整数：理论上只受 JVM 内存限制，没有数值上限。
2. 不可变类：所有运算都不会修改原对象，而是返回一个全新的 BigInteger 对象。
3. 无运算符号：不支持 + - * / % 这些运算符，必须调用专属方法。
4. 精度绝对无损：整数运算，不存在精度丢失这种糟心事。
5. 性能偏低：底层基于数组存储大数，运算开销远大于基本类型，不适合高频小数值运算。

三、BigInteger 对象创建（4 种常用方式）

BigInteger 没有无参构造，你得通过指定数值、字符串、进制或者数组来创建对象。

1. 普通数值创建

// 通过 long 数值创建（适合 long 范围内数值）
BigInteger num1 = BigInteger.valueOf(123456);
// 负数创建
BigInteger num2 = BigInteger.valueOf(-98765);

2. 字符串创建（推荐，支持超大数）

这是唯一可以直接定义超出 long 范围超大整数的方式，开发首选。

// 远超 long 最大值的超大整数
BigInteger bigNum = new BigInteger("999999999999999999999999999999");

3. 指定进制创建

可以把指定进制的数字字符串转为十进制的 BigInteger。

// 将二进制 1010 转为十进制数字
BigInteger binaryNum = new BigInteger("1010", 2);
// 将十六进制转为十进制
BigInteger hexNum = new BigInteger("FF", 16);

4. 系统常量对象（常用）

内置了几个常用常量，不需要 new 对象，节省内存：

BigInteger.ZERO;    // 0
BigInteger.ONE;     // 1
BigInteger.TWO;     // 2
BigInteger.TEN;     // 10

四、核心算术运算方法（重点）

所有运算原对象不变，返回新对象，必须接收返回值——这一点非常重要，很多人踩过坑。

BigInteger a = new BigInteger("100000000000000000000");
BigInteger b = new BigInteger("200000000000000000000");
// 1. 加法
BigInteger addRes = a.add(b);
// 2. 减法
BigInteger subRes = a.subtract(b);
// 3. 乘法
BigInteger mulRes = a.multiply(b);
// 4. 除法（整除，只取整数部分）
BigInteger divRes = b.divide(a);
// 5. 取模
BigInteger modRes = b.mod(a);
// 6. 求绝对值
BigInteger absRes = subRes.abs();
// 7. 取反
BigInteger negRes = a.negate();
// 8. 幂运算
BigInteger powRes = a.pow(3);
// 9. 最大/最小值
BigInteger maxRes = a.max(b);
BigInteger minRes = a.min(b);

五、精准除法（整除+余数）

普通的 divide 只返回商，divideAndRemainder 可以同时拿到商和余数，算法题里高频使用。

BigInteger num = new BigInteger("100");
BigInteger divisor = new BigInteger("3");
// 数组：[0]商，[1]余数
BigInteger[] res = num.divideAndRemainder(divisor);
System.out.println("商：" + res[0]);
System.out.println("余数：" + res[1]);

六、数值比较方法

千万注意：禁止使用 > < == 来比较 BigInteger 对象，必须用专属方法。

BigInteger x = new BigInteger("888");
BigInteger y = new BigInteger("666");
// compareTo：大于返回1，等于返回0，小于返回-1
int cmp = x.compareTo(y);
// 判断是否相等（推荐，杜绝 == 地址比较坑）
boolean eq = x.equals(y);
// 判断正负、零
boolean zero = x.equals(BigInteger.ZERO);
boolean positive = x.compareTo(BigInteger.ZERO) > 0;
boolean negative = x.compareTo(BigInteger.ZERO) < 0;

七、进制转换与类型转换

1. 十进制转任意进制字符串

BigInteger num = new BigInteger("255");
String binary = num.toString(2);   // 转二进制
String oct = num.toString(8);     // 转八进制
String hex = num.toString(16);     // 转十六进制

2. 大数转基本类型

注意：超出基本类型范围会抛异常，转换前最好先判断一下范围。

// 转 long（范围溢出抛异常）
long longVal = num.longValue();
// 转 int
int intVal = num.intValue();
// 精准判断是否可以转为 long
boolean canLong = num.bitLength() <= 63;

八、位运算与工具方法（算法常用）

BigInteger n = new BigInteger("10");
n.and(BigInteger.ONE);      // 与运算
n.or(BigInteger.ZERO);       // 或运算
n.xor(BigInteger.TWO);      // 异或运算
n.not();                    // 取反
n.shiftLeft(2);             // 左移（乘2^2）
n.shiftRight(1);            // 右移（除2）
// 获取二进制位数
int bitLen = n.bitLength();
// 判断是否为素数
boolean prime = n.isProbablePrime(50); // 参数为置信度

九、BigInteger 核心易错点

1. 不可变特性坑

所有运算不改变原对象，不接收返回值等于白算——这个坑，新手老手都容易掉进去。

// 错误写法
BigInteger a = BigInteger.TEN;
a.add(BigInteger.TEN);
System.out.println(a); // 仍然是10
// 正确写法
a = a.add(BigInteger.TEN);

2. 不能用 == 比较数值

== 比较的是对象地址，equals 比较数值内容，所以必须用 equals / compareTo。

3. 禁止基本类型运算符

BigInteger 是对象，不支持 + - * /，编译直接报错，必须调用方法。

4. 超大数必须字符串构造

超出 long 范围的数值，不能用 valueOf 或数字直接赋值，只能用字符串构造。

十、BigInteger 与基本类型选型规范

• 普通数值、范围在 long 内：优先使用 long，性能极高。
• 数值超大、超出 long 范围：必须使用 BigInteger。
• 频繁循环运算、高性能场景：尽量规避 BigInteger，优先基本类型。
• 算法题、大数加密、进制运算、素数判断：首选 BigInteger。

十一、总结

1. BigInteger 是 ja va.math 包下的超大整数不可变类，解决基本类型数值溢出问题。
2. 所有运算均返回新对象，原数据不改变，必须接收返回值。
3. 无运算符重载，所有加减乘除、位运算、比较均需调用专属 API。
4. 支持任意进制转换、素数判断、幂运算、精准取余，是算法与加密开发必备。
5. 缺点是性能弱于基本类型，仅用于大数场景，不适合高频小数值运算。