Java 如何将此代码从long转换为BigInteger

这是一个获取素数的代码，我已经尽可能地提高了效率，但问题是我不能将它转换为BigInteger，只要不能保存那么多信息；代码如下：

public class p3{
    static long perfectNumber;
    static long mersenne;

    public static void main(String[] args) {
        long p = 2;
        while (true) {
            if( p % 2 == 0&&p!=2){
                p++;
            }
            else{
                if (isPrime(p) == true) {
                    mersenne = (long) (Math.pow(2, p) - 1);
                    if (isPrime(mersenne) == true) {
                        perfectNumber = (long) Math.pow(2, (p - 1)) * mersenne;
                        System.out.println(perfectNumber);
                    }
                }
                p+=1;
            }
        }
    }
    private static boolean isPrime(long testPrime) {
        for (long i = 3; i < Math.sqrt(testPrime); i += 2) {
            if (testPrime % i == 0) {
                    return false;
            }
        }
        return true;
    }
}

公共类p3{
静态长余数；
静态长梅森；
公共静态void main（字符串[]args）{
长p=2；
while（true）{
如果（p%2==0&&p！=2）{
p++；
}
否则{
if（isPrime（p）=真）{
mersenne=（长）（数学pow（2，p）-1）；
if（isPrime（mersenne）=true）{
perfectNumber=（long）Math.pow（2，（p-1））*mersenne；
System.out.println（perfectNumber）；
}
}
p+=1；
}
}
}
私有静态布尔值isPrime（长testPrime）{
for（长i=3；i

我尝试使用BigInteger，但代码不起作用，因为我无法使用 带pow的大整数指数

你不需要。指数不需要像梅森素数和完美数那样大。他们可以有自己独立的

isPrime（）

test。事实上，它们需要是

int

，而不是

long

，才能满足

biginger.pow（）

下面是你想要的，但可能不是你想要的。我怀疑，由于时间限制，@WJS会将您推向一个不同的方向，您可能会在原始代码之外获得更多的完美数字

import java.math.BigInteger; 

public class p3 {
    static BigInteger TWO = new BigInteger("2");
    static BigInteger THREE = new BigInteger("3");

    public static void main(String[] args) {
        int p = 2;

        while (true) {
            if (isPrime(p)) {
                BigInteger mersenne = TWO.pow(p).subtract(BigInteger.ONE);

                if (isPrime(mersenne)) {
                    System.out.println(TWO.pow(p - 1).multiply(mersenne));
                }
            }

            p += (p == 2) ? 1 : 2;
        }
    }

    private static boolean isPrime(BigInteger number) {
        if (number.mod(TWO).equals(BigInteger.ZERO)) {
            return number.equals(TWO);
        }

        for (BigInteger i = THREE; number.compareTo(i.multiply(i)) >= 0; i = i.add(TWO)) {
            if (number.mod(i).equals(BigInteger.ZERO)) {
                return false;
            }
        }

        return true;
    }

    private static boolean isPrime(int number) {
        if (number % 2 == 0) {
            return number == 2;
        }

        for (int i = 3; number >= i * i; i += 2) {
            if (number % i == 0) {
                return false;
            }
        }

        return true;
    }
}

输出

> java p3
6
28
496
8128
33550336
8589869056
137438691328
2305843008139952128
2658455991569831744654692615953842176

您的原始代码输出0以代替上面的最终（37位）数字。因此，当前的问题实际上是

long

无法保存足够的信息。但是超过这一点，你就不能用上面的算法计算得足够快

如果我们对上面的代码做一些简单的操作，比如替换这一行：

 if (isPrime(mersenne)) {

与：

---

这段代码会先吐出前20个完整数字，然后再慢下来爬行。根据需要调整

isProbablePrime（）

的确定性参数。

您遇到了什么问题？是否查看了其文档？首先，问题不是那么长，因为我们无法保存足够的信息。它可以容纳超过100000万亿的19位数字。没有足够的时间用你的算法甚至是筛子来计算那个数量级的素数。但是，使用

biginger

将允许您使用sophistcated

isProbablePrime

方法。因此，请阅读建议的文档，只做简单的更改。@goon我需要将其转换为biginger，只要不足以实现完美数字。请注意WJS编写的内容。您的

isPrime（）

方法需要很长时间才能使

p

大于一个字节，更不用说长字节了。已知最大的梅森素数是p=82589933。

if (mersenne.isProbablePrime(10)) {