bigInt报错（Exception in thread “main“ java.lang.NullPointerException: Cannot invoke “java.math.BigInt）

空指针异常，不太会用BigInteger,以为初始化和int一样，直接等于就行了

看了一下源代码，初始化赋值只有下面几种情况智能赋值这几个，而且必须用对应的英文来表示

-1 0 1 2 10 

2.斐波那契数列最大公约数 - 蓝桥云课

一开始用int 来初始化数组，我还没有意识到问题的严重性，直到结果返回-1我才意识到好像没有那么简单，我丢，然后我把前2020个斐波那契数一个一个打印出来（用long 打印的）结果我发现后面的全是负数，我就知道，这绝对溢出了，我丢，然后就用bigInteger

发现还不会用

我一开始的代码如下

给bigInteger类直接也是用上加号了【捂脸】

ackage Lanqiao;

import java.math.BigInteger;

/**
 * @author zb
 * date2025/3/20 21:05
 */
public class L1006 {
    public static void main(String[] args) {
        BigInteger f[] = new BigInteger[2030];
        f[1] = BigInteger.valueOf(1);
        f[2] = BigInteger.valueOf(1);
        for (int i = 3; i <= 2020 ; i++) {
           f[i].add(f[i-1]);
           f[i].add(f[i-2]);
        }
        for (int i = 1; i <=2020 ; i++) {
            System.out.println(f[i]);
        }
        System.out.println(f[520].gcd(f[2020]));
    }


}

从初始化 第一个斐波那契数和第二个斐波那契数的时候也可以这样初始化

 f[1] = new BigInteger("1");
        f[2] = new BigInteger("1");

1. BigInteger 是一个类，不是基本数据类型

• 基本数据类型（如 int、long）可以直接使用算术运算符进行运算。例如

• int a = 5;
  int b = 3;
  int c = a + b; // 直接使用 + 运算符

  BigInteger 是一个对象类型，它封装了大整数的值，并提供了专门的方法来进行运算。例如

BigInteger a = new BigInteger("5");
BigInteger b = new BigInteger("3");
BigInteger c = a.add(b); // 使用 add() 方法进行加法

2. 为什么不能直接使用 + 运算符？

• 运算符重载的限制：Java 不支持对自定义类（如 BigInteger）的运算符重载。因此，+ 运算符只能用于基本数据类型，而不能用于对象类型。
• BigInteger 的不可变性：BigInteger 是不可变类，每次运算都会返回一个新的 BigInteger 对象，而不是修改原有对象。这与基本数据类型的运算方式不同。

3. 正确使用 BigInteger 进行运算

BigInteger 提供了专门的方法来进行算术运算，例如：

• 加法：add(BigInteger val)
• 减法：subtract(BigInteger val)
• 乘法：multiply(BigInteger val)
• 除法：divide(BigInteger val)

4. 为什么在斐波那契数列中不能用 f[i] = f[i-1] + f[i-2]？

在斐波那契数列的计算中，如果 f 是一个 BigInteger 数组，直接使用 + 运算符会导致编译错误，因为 + 不能用于 BigInteger 对象。

5. 总结

特性	基本数据类型（如 int）	BigInteger
类型	基本数据类型	类（对象类型）
运算方式	直接使用 +、- 等运算符	使用 add()、subtract() 等方法
精度	有限（如 int 最大 2³¹-1）	任意精度（无上限）
适用场景	小规模整数计算	大规模整数计算（如斐波那契数列）

因此，BigInteger 不能直接使用 + 运算符，必须通过其提供的方法进行运算。这种方式虽然稍显繁琐，但能够确保处理超大整数时的精确性和可靠性。