如何在java中优化算法以确定10位长素数

我目前还不熟悉java和一般编程，我正在研究一种算法，可以确定特定给定范围内的素数。目前，它的工作范围是6个10亿以下的数字，当我试图确定一个10位数长的数字时，它失败了。我知道它需要更改为长，因为数字超出范围，但我不确定如何更改

这是确定数字是否为素数的代码部分：

public ArrayList<Integer> getPrimes(int StartPos, int n) {
    ArrayList<Integer> primeList = new ArrayList<>();

    boolean[] primes = new boolean[n + 1];
    for (int i = StartPos; i < primes.length; i++) {
        primes[i] = true;
    }
    int num = 2;
    while (true) {
         for (int i = 2;; i++) {
              int m = num * i;
              if (m > n) {
                    break;
              } else {
                    primes[m] = false;
              }
         }
         boolean nextNum = false;
         for (int i = num + 1; i < n + 1; i++) {
              if (primes[i]) {
                    num = i;
                    nextNum = true;
                    break;
              }
         }
         if (!nextNum) {
              break;
         }
    }
    for (int i = 0; i < primes.length; i++) {
         if (primes[i]) {
            primeList.add(i);           
         }      
    }
    return primeList;  
}

public ArrayList getPrimes（intstartpos，intn）{
ArrayList primeList=新的ArrayList（）；
布尔[]素数=新布尔[n+1]；
for（int i=StartPos；in）{
打破
}否则{
素数[m]=假；
}
}
布尔nextNum=false；
对于（int i=num+1；i

我在网上查了一下，发现也许我可以用矢量来做，但我没有使用矢量的经验，而且矢量比数组慢。

你可以试试BigInteger#isProbablePrime:

import java.math.biginger；
导入java.util.List；
导入java.util.stream.collector；
导入java.util.stream.LongStream；
//爪哇8
公共类查找时间{
公共静态void main（字符串[]args）{
System.out.println（“1-100素数：+FindTime（1L，99L））；
System.out.println（“一些10位数的素数：+findpremes（99_999_999_999L，20000L））；
}
私有静态列表FindTime（长启动、长数量）{
返回LongStream.rangeClosed（开始，开始+数量）。筛选器（v->
biginger.valueOf（v.isProbablePrime（1））.boxed（）.collect（Collectors.toList（））；
}
}

您可以尝试BigInteger#isProbablePrime:

import java.math.biginger；
导入java.util.List；
导入java.util.stream.collector；
导入java.util.stream.LongStream；
//爪哇8
公共类查找时间{
公共静态void main（字符串[]args）{
System.out.println（“1-100素数：+FindTime（1L，99L））；
System.out.println（“一些10位数的素数：+findpremes（99_999_999_999L，20000L））；
}
私有静态列表FindTime（长启动、长数量）{
返回LongStream.rangeClosed（开始，开始+数量）。筛选器（v->
biginger.valueOf（v.isProbablePrime（1））.boxed（）.collect（Collectors.toList（））；
}
}

你说你在学习，所以我会用伪代码给你一个提纲，而不是答案

一般来说，在一个范围内寻找素数的方法是：

repeat
  pick a number in the range
until (the number is prime)

你想要一个十位数的数字。在避免明显的非素数的同时生成候选项的一种方法是：

start with digit in [1..9]  // No leading zero.
repeat 8 times
  append a digit in [0..9]
endrepeat
append a digit in [1, 3, 7, 9]  // Final digits for large primes.

这会给你一个十位数的素数

现在，您需要测试以检查它是否为素数

有像米勒·拉宾（Miller Rabin）这样的测试，你可以尝试，但如果你是一个真正的初学者，可能不会。我建议设置一个Eratosthenes筛子，筛子的数量为10000，即上限1000000000的平方根。这将使您能够快速访问数字平方根以下的所有素数。仅在程序开始时设置一次筛选。使其成为一个单独的类，并包含一个

intnextprime（intn）

方法，该方法返回所提供参数后的下一个素数。一旦设置好，您就可以编写一个试算法来测试您的十位数：

boolean method isPrime(tenDigitNumber)
  testPrime <- 2
  limit <- square root of tenDigitNumber  // Only calculate this once.
  while (testPrime < limit)
    if (tenDigitNumber MOD testPrime == 0)
      return false  // Number is not prime.
    else
      testPrime <- sieve.nextPrime(testPrime)
    endif
  endwhile
  return true  // If we get here then the number is prime.
end isPrime

布尔方法isPrime（趋势编号）
testPrime你说你正在学习，所以我将用伪代码给你一个提纲，而不是答案

一般来说，在一个范围内寻找素数的方法是：

repeat
  pick a number in the range
until (the number is prime)

你想要一个十位数的数字。在避免明显的非素数的同时生成候选项的一种方法是：

start with digit in [1..9]  // No leading zero.
repeat 8 times
  append a digit in [0..9]
endrepeat
append a digit in [1, 3, 7, 9]  // Final digits for large primes.

这会给你一个十位数的素数

现在，您需要测试以检查它是否为素数

有像米勒·拉宾（Miller Rabin）这样的测试，你可以尝试，但如果你是一个真正的初学者，可能不会。我建议设置一个Eratosthenes筛子，筛子的数量为10000，即上限1000000000的平方根。这将使您能够快速访问数字平方根以下的所有素数。仅在程序开始时设置一次筛选。使其成为一个单独的类，并包含一个
intnextprime（intn）
方法，该方法返回所提供参数后的下一个素数。一旦设置好，您就可以编写一个试算法来测试您的十位数：

boolean method isPrime(tenDigitNumber)
  testPrime <- 2
  limit <- square root of tenDigitNumber  // Only calculate this once.
  while (testPrime < limit)
    if (tenDigitNumber MOD testPrime == 0)
      return false  // Number is not prime.
    else
      testPrime <- sieve.nextPrime(testPrime)
    endif
  endwhile
  return true  // If we get here then the number is prime.
end isPrime

布尔方法isPrime（趋势编号）
testPrime是的，向量比ArrayList慢。你应该找到一种不同的方法，而不是用eratosthenes筛选。除了将计算分为两种方法之外，我找不到你问题的任何答案，第一种方法是筛选。
我知道需要将[算术]更改为long，因为[10]位超出了[int]的范围。
更糟糕的是，筛选通常表示奇数，5E9大于Java的最大索引值
Integer。MAX_值
->。是的，向量比ArrayList慢。你应该找到一种不同于eratosthenes筛选的方法。除了将计算分为两种方法之外，我找不到任何答案，第一种方法是筛选法。
我知道[算术]需要更改为long，因为[10]位超出了[int]的范围。
更糟糕的是，筛选法通常表示奇数，而5E9表示l