Java temp=0在查找素数时扮演什么角色？

我有以下代码来打印从

2

到

100

的所有素数：

int number1 = 2, number2 = 100, temp = 0;
System.out.println("prime numbers between" + number1 + "and" + number2 + "are :");

for (int i = number1; i <= number2; i++) {
    for (int j = 2; j <= i / 2; j++) {
        if (i % j == 0) {
            temp = 1;
            break;
        } else {
            temp = 0;
        }
    }

    if (temp == 0) {
        System.out.println(i);
    }
}

int number1=2，number2=100，temp=0；
System.out.println（“介于“+number1+”和“+number2+”之间的素数是：”）；
对于（int i=number1；i）解释
仔细查看您的循环逻辑流：

for (int i = number1; i <= number2; i++) { 
    for (int j = 2; j <= i / 2; j++) {
        if (i % j == 0) {
            temp = 1;
            break;
        } else {
            temp=0;
        }
    }

    if (temp == 0) {
        System.out.println(i);
    }
}


跳过内部循环
这意味着对于外循环的第一次迭代，例如
i=2
内循环的条件计算为：

j <= i / 2
// which is
2 <= 2 / 2
// which is
2 <= 1

迭代也是如此，
i=3

i=4
是实际进入内部循环并开始用
0
或
1
覆盖
temp
的第一次迭代


temp==0的含义
因此，在外循环的第一次迭代（
i=2
，
i=3
）中，
temp
的初始状态起作用，因为它决定是否打印
i

因此，您需要它以
0
开头，以便在输出中包含第一个值，甚至没有输入内部循环


笔记
也就是说，以这种方式使用
temp
过于复杂。最好将它移动到实际需要它的地方，在循环内部，给它一个更好的名称，并将其更改为
布尔值
。总之，您可以将代码简化为：

int min = 2;
int max = 100;
System.out.println("prime numbers between" + min + "and" + max + "are :");

for (int i = min; i <= max; i++) {
    boolean isPrime = true;
    for (int j = 2; j <= i / 2; j++) {
        if (i % j == 0) {
            isPrime = false;
            break;
        }
    }
    if (isPrime) {
        System.out.println(i);
    }
}

intmin=2；
int max=100；
System.out.println（“介于“+min+”和“+max+”之间的素数是：”）；
对于（int i=min；i您需要了解变量
temp
在此代码中的作用

变量
temp
的行为类似于一个标志，意味着每当发现该数字可被另一个数字整除时，
temp
变量设置为
1
，代码停止检查

如果我们扫描到
i/2
之前的所有数字，并且变量
temp
仍然是0，这意味着我们没有找到任何可以除以当前数字
i
的数字
j
，那么当前数字就是素数

编辑：
temp=0
一开始的作用是假设所有的数字都是素数。如果后来发现的数字是可除的，那么我们分配
temp=1
，我们知道这个数字不是素数。
在
temp
中的作用是简单地指示是否找到素数。然后使用该值来控制打印测试中的e值。但实际上并不需要它（如注释中所述，应该是一个
布尔值
）

这里有一种方法可以让你在不使用该值的情况下提高努力程度

除除以已找到的素数外，您还可以通过执行以下操作来提高效率：


如果第一个素数是偶数，请检查以确保它不是2
如果是，请打印出来
如果为偶数，则按
1
递增
number1
，使其为奇数
然后开始用候选数和除数进行迭代，得到奇数
不要除以任何数值>候选数的平方根。否则，你就是在浪费时间。例如，如果97不能被3,5,7,11中的任何一个整除，那么它必须是素数，因为任何较大的整除数都会返回一个已经检查过的商<11
您不需要
temp
值。如果数字被除，只需继续到外部循环。否则，打印数字

将nextBit初始化为第一个素数

int nextBit = 2; // essentially bitSet.nextClearBit(0);

当下一位小于终端值的平方根时，继续循环

while (nextBit <= Math.sqrt(number2)) {
    // mark every prime position after this one.
    for (int i = 2*nextBit; i < number2; i += nextBit) {
        bits.set(i);
    }
    // the next clear bit after the previous prime must be a prime 
    // since it is next unset bit
    nextBit = bits.nextClearBit(nextBit+1);
}

while（下一步，它是一个
int
，没有任何意义。它实际上是一个布尔值，如果它被声明为布尔值，它的意义会更清楚。这在技术上与问题无关，但这会打印出从2到num2/2的所有素数，在这种情况下，它是50@TruVortex_07这可能只是我的编辑错误，因为原始代码有
number´´
，我试着猜测恢复它。感谢您的指出和
的帮助（int j=2；j和temp不是必需的。如果数字是可除的，则执行
continue outer；
并将标签
outer
放在外循环上。一旦耗尽内循环，则打印该值。最后，分别检查可除2。然后从3开始，将其余值增加2。
public static boolean isPrime(int candidate) {
    for (int i = 2; i <= candidate / 2; i++) {
        if (candidate % i == 0) {
            return false;
        }
    }

    return true;
}

int min = 2;
int max = 100;
System.out.println("prime numbers between" + min + "and" + max + "are :");

for (int i = min; i <= max; i++) {
    if (isPrime(i)) {
        System.out.println(i);
    }
}


int number1 = 2, number2 = 100;
System.out.println("prime numbers between" + number1 + "and"
        + number2 + "are :");
if (number1 % 2 == 0) {
    if (number1 == 2) {
        System.out.println(2);
    }
    number1++;
}
outer:
for (int i = number1; i <= number2; i += 2) {
   int max = (int)Math.sqrt(i);
   for (int j = 3; j <= max; j += 2) {
      if (i % j == 0) {
        // try next candidate
        continue outer;
      } 
   }
   // must be a prime so print it.
   System.out.println(i);
}

BitSet bits = new BitSet();
bits.set(0,2); // set bits 0 and 1

int nextBit = 2; // essentially bitSet.nextClearBit(0);

while (nextBit <= Math.sqrt(number2)) {
    // mark every prime position after this one.
    for (int i = 2*nextBit; i < number2; i += nextBit) {
        bits.set(i);
    }
    // the next clear bit after the previous prime must be a prime 
    // since it is next unset bit
    nextBit = bits.nextClearBit(nextBit+1);
}

// This is done by simply printing all the bit positions
// that are clear up to the terminal value.
int i = bits.nextClearBit(0);
while (i < number2) {
    System.out.println(i);
    i = bits.nextClearBit(i+1);
}