Java 我需要得到从1到大数的所有素数？

我需要创建一个程序，可以得到从1到大数的所有素数。我有一个

getPrime

方法，如果数字是prime，则返回

true

，如果不是prime，则返回

false

。当我使用这个方法和while循环来获得一个从1到一个大数的素数列表时，它会不断返回24，然后是4，然后是5。下面代码中的变量

end

，是在一个素数类运行程序中单独请求的。这是我的密码：

public class Prime 
{

    private long userNumber;
    private int numRoot;
    private int x;
    private boolean isPrime;
    private int factors;
    private long end;
    private int i;

    public void setUserNumber(long num)
    { 
       userNumber = num;
    }

    public void setEndNumber(long n)
    { 
        end = n;
    }

    public boolean getPrime()
    {
        numRoot = ((int)Math.sqrt(userNumber));


        for (x=2; x<=numRoot; x++)
        {
            if ((userNumber % x) == 0)
            {
                factors++;        
            }
        }

        if (factors >1) {
            isPrime = false;
        }
        else {
            isPrime = true;
        }
        return  isPrime;
    }  
    public void getPrimeList()
    {
        if(end < 2) {
            System.out.println("No prime numbers");
            System.exit(0);
        }
        System.out.printf("\nThe prime numbers from 1 to %d are: \n 2", end);
        Prime primeNum = new Prime();
        i = 3;
        while( i <= end )
        {
            userNumber = i;
            getPrime();
            if (isPrime == true)
            {
                System.out.println(userNumber);
            }
            i++;
        }
        System.out.println();
    }
 }

公共类素数
{
私有长用户号；
私有int numRoot；
私人INTX；
私有布尔互质；
私人因素；
私人长尾；
私人互联网i；
public void setUserNumber（long num）
{ 
userNumber=num；
}
公共无效setEndNumber（长n）
{ 
end=n；
}
公共布尔getPrime（）
{
numRoot=（（int）Math.sqrt（userNumber））；
对于（x=2；x1）{
isPrime=false；
}
否则{
isPrime=true；
}
返还优先权；
}  
public void getPrimeList（）
{
如果（结束<2）{
System.out.println（“无素数”）；
系统出口（0）；
}
System.out.printf（“\n从1到%d的素数为：\n 2”，结束）；
Prime primeNum=新的Prime（）；
i=3；
而（i
public类PrimeTest{
私有静态final int MAX\u NUM=Integer.MAX\u VALUE；//您的大数字
公共静态void main（字符串[]args）{
整数计数=0；
对于（int i=0；i素数
p
应具有介于2和
sqrt（p）
之间的零因子，但此处允许一个：

if (factors >1){
    isPrime = false;
}

事实上，根本不需要计算因素，您可以直接计算

if ((userNumber % x) == 0) {
    return false; 
}

但是，如果您需要以任何方式计算因子，我建议在开始时将
因子显式设置为
0
。依赖隐式初始值不是一个好的做法。
问题是您在
getPrime
中使用了太多实例变量，导致无意中从prev继承状态IOU迭代。更准确地说，
因子
应该在
getPrime
开始时重置为
0

更好的方法是将
x
、
numRoot
、
isPrime
和
因子
作为
getPrime
的局部变量：

public boolean getPrime()
{
    int factors = 0;
    boolean isPrime;
    int numRoot = ((int) Math.sqrt(userNumber));

    for (int x=2; x<=numRoot; x++)
    {
        if ((userNumber % x) == 0)
        {
            factors++;        
        }
    }

    if (factors >1){
        isPrime = false;
    } else {
        isPrime = true;
    }
    return  isPrime;
}

    public boolean getPrime(int userNumber)
    {
        // ...

并称之为：

while( i <= end )
{
            isPrime = getPrime(i);
    if (isPrime)
    {
        System.out.println(userNumber);
    }
    i++;
}

while（i
public void getPrimes（int N）{
对于（inti=2；i来说，下面的代码是用C#编写的，尽管只需很少修改即可在Java中工作。
我使用long作为数据类型，因为您在说“大量”时没有具体说明

公共静态bool isPrime（长数字）
{
如果（Number==1）{返回false；}
int i=2；
while（i

它可以像这样应用，同样这是C#，但在Java中只需很少修改即可工作

    while (i <= LARGE_NUMBER)
    {
        Console.Write((isPrime(i) ? i.ToString() + "\n" : ""));
        i++;
    }

while（i您的算法对于您的任务来说是错误的解决方案。任务是找到从2到N的所有素数，合适的算法是Eratosthenes的筛（请参阅讨论筛算法的基础知识和优化的epic rant。）

众所周知，所有素数要么是2,3,5,7,11,13，要么是

30*k-13, 30*k-11, 30*k-7, 30*k-1, 30*k+1, 30*k+7, 30*k+11, 30*k+13,

对于k=1,2,3

因此，生成一个数组布尔值isPrime[N+1]，将all设置为true，对于上述形式的任何候选素数p，直到pp>N，如果isPrime[p]为true，则将k=2,3,4，…N/p的所有isPrime[kp]=false


intn；
布尔isPrime[]=新布尔[N+6]；
静态空隙交叉（int p）{
对于（int k=5*p，d=2；k这不应该在“javascript”下。您发布的代码是用java编写的。Google用于“素数”。对于前10K左右的值，有在线表格。您永远不会将变量因子重置为0。
1
不是素数。
for（int i=2；i
    public static bool isPrime(long Number)
    {
        if (Number == 1) { return false; }
        int i = 2;
        while (i < Number)
        {
            if (Number % i++ == 0) { return false; }
        }
        return true;
    }

    while (i <= LARGE_NUMBER)
    {
        Console.Write((isPrime(i) ? i.ToString() + "\n" : ""));
        i++;
    }

30*k-13, 30*k-11, 30*k-7, 30*k-1, 30*k+1, 30*k+7, 30*k+11, 30*k+13,

int N;
Boolean isPrime[] = new Boolean[N+6];

static void cross_out(int p) {
    for(int k=5*p, d=2; k<N; k+=d*p, d=6-d) {
         isPrime[k]=false;
    }
}

static void sieve() {
    for(int k=0; k<N; k+=6) {
        isPrime[k  ]=isPrime[k+2]=false;
        isPrime[k+3]=isPrime[k+4]=false;
        isPrime[k+1]=isPrime[k+5]=true;
    }
    for(int k=5, d=2; k*k<N; k+=d; d=6-d) {
        if(isPrime[k]) cross_out(k);
    }
}