Java 打印从2到1000的素数

我正在编写一个代码，将2到1000之间的所有素数写入一个名为primes.txt的文件中。由于某种原因，我无法找出解决这个问题的正确方法

import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintWriter;

public class Problem6 {

    /**
     * @param args
     * @throws FileNotFoundException 
     */
    public static void main(String[] args) throws FileNotFoundException {
        PrintWriter prw = new PrintWriter("primes.txt");
        for (int i = 2; i <= 1000; i++){
            if (checkIfPrime(i) == true){
                System.out.println(i);
                prw.println(i);
            }
        }
    }

    public static boolean checkIfPrime (int num){
        boolean isPrime = true;  
        for (int i = 2; i <= 1000; i++){
            if ( num % i == 0 ){
                isPrime = false;
            }
        }

        return isPrime;
    }
}

导入java.io.File；
导入java.io.FileNotFoundException；
导入java.io.PrintWriter；
公共课问题6{
/**
*@param args
*@抛出FileNotFoundException
*/
公共静态void main（字符串[]args）引发FileNotFoundException{
PrintWriter prw=新的PrintWriter（“primes.txt”）；
对于（int i=2；i将
checkIfPrime（int num）
中的
for
条件更改为

for (int i = 2; i < num; i++) {

for（int i=2；i


顺便说一句，
if（checkIfPrime（i）=true）{
可以写成
if（checkIfPrime（i））{
将
checkIfPrime（int num）
中的
条件更改为

for (int i = 2; i < num; i++) {

for（int i=2；i


顺便说一句，
if（checkIfPrime（i）=true）{
可以写成
if（checkIfPrime（i））{
如果一个数
num
不能被任何其他大于一小于
num的数整除，那么它就是素数。这在你的代码中是什么？：-）
如果一个数
num
不能被任何其他大于一且小于
num的数整除，那么它就是素数。它在代码中的位置是什么？：-）
当您将第一个数
2
传递到
checkIfPrime
时会发生什么？它将取2的剩余部分除以2，即0，错误地声称
2
不是素数

您需要在实际到达
num
之前停止测试剩余量。在
i
到达
num
之前停止
i
for循环（实际上，您可以在
i
达到
num
的平方根后停止）

for（int i=2；i

甚至

for (int i = 2; i <= Math.sqrt(num); i++){

对于（int i=2；i当您将第一个数字
2
传递到
checkIfPrime
时会发生什么？它将取2的剩余部分除以2，即0，错误地声称
2
不是素数

您需要在实际到达
num
之前停止测试剩余量。在
i
到达
num
之前停止
i
for循环（实际上，您可以在
i
达到
num
的平方根后停止）

for（int i=2；i

甚至

for (int i = 2; i <= Math.sqrt(num); i++){

for（int i=2；i只通过检查素数的除法，计算速度会更快。任何非素数都可以被比自身小的素数整除

    static List<Integer> primes = new ArrayList<Integer>();

public static void main(String[] args) {
    for (int i = 2; i < 10000; i++) {
        if(checkPrime(i)){
            primes.add(i);
        }
    }
    System.out.println(primes);
}

private static boolean checkPrime(int n) {
    for (Integer i : primes) {
        if(i*i > n ){
            break;
        }else if(n%i==0 )
            return false;
     }
    return true;
}

static List primes=new ArrayList（）；
公共静态void main（字符串[]args）{
对于（int i=2；i<10000；i++）{
if（检查素数（i））{
加上（i）；
}
}
系统输出打印项次（素数）；
}
私有静态布尔校验素数（int n）{
for（整数i：素数）{
如果（i*i>n）{
打破
}else if（n%i==0）
返回false；
}
返回true；
}
通过只检查素数的除法，计算速度会更快。任何非素数都可以被比自身小的素数整除

    static List<Integer> primes = new ArrayList<Integer>();

public static void main(String[] args) {
    for (int i = 2; i < 10000; i++) {
        if(checkPrime(i)){
            primes.add(i);
        }
    }
    System.out.println(primes);
}

private static boolean checkPrime(int n) {
    for (Integer i : primes) {
        if(i*i > n ){
            break;
        }else if(n%i==0 )
            return false;
     }
    return true;
}

static List primes=new ArrayList（）；
公共静态void main（字符串[]args）{
对于（int i=2；i<10000；i++）{
if（检查素数（i））{
加上（i）；
}
}
系统输出打印项次（素数）；
}
私有静态布尔校验素数（int n）{
for（整数i：素数）{
如果（i*i>n）{
打破
}else if（n%i==0）
返回false；
}
返回true；
}
以下是如何在a上“硬编码”以打印高达1000的素数

primes_1000（）
{
//2-3-5-7轮
int wh[48]={10,2,4,2,4,6,2,6,4,2,4,6,6,2,6,4,2,6,2,6,4,6,8,4,2,4，
2,4,8,6,4,6,2,4,6,2,6,6,4,2,4,6,2,6,4,2,4,2,10,2};
//核心素数的倍数，每一个都有指向轮子的指针
int m[7][4]={1,11,11*11}，{2,13,13,13*13}，{3,17,17*17}，
{4,19,19,19*19}, {5,23,23,23*23}, {6,29,29,29*29},
{7,31,31,31*31} };    // 23*23 = 529 
int i=1，p=11，k=0；
印刷品（2）；印刷品（3）；印刷品（5）；印刷品（7）；
p=11；//方向盘上的第一个数字-第一个候选者
做{
//最小重复倍数为121*13，==>1000以下无重复！
对于（k=0；k<7；++k）{
如果（p==m[k][3]）{//p是m[k][1]素数的倍数：
m[k][2]+=wh[m[k][0]+]；//方向盘上的下一个数字
m[k][3]=m[k][1]*m[k][2]；//m[k][1的下一个倍数
m[k][0]]=48；//索引到车轮中
打破
}
}
如果（k==7）{//32以下无素数的倍数-
打印（p）；//-1000以下的素数！（32^2=1024）
}
p+=wh[i++]；//轮盘上的下一个数字
i%=48；//环绕以模拟循环列表
}p<1000；
}

对于低于500的素数，只需保持4个筛变量，对于轮的固有素数2,3,5,7以上的额外核心素数{11,13,17,19}

（另见）

m
是基本素数及其在轮子上的倍数的字典（
multiplesOf（p）=map（multipleby（p），rollWheelFrom（p））
，每个都有自己的索引进入轮子。它实际上应该是一个优先级队列，按倍数的值排序

对于一个真正的无界解，当候选素数达到下一个素数的平方时，可以一个素数一个素数地扩展字典。
以下是如何在a上“硬编码”以打印高达1000的素数

primes_1000（）
{
//2-3-5-7轮
int wh[48]={10,2,4,2,4,6,2,6,4,2,4,6,6,2,6,4,2,6,2,6,4,6,8,4,2,4，