埃氏筛（Java）：找出所有小于等于给定整数n的质数的算法

思路：

标记排除法：假设所有数都是质数，然后从最小的质数2开始，依次标记其倍数为非质数，剩余未被标记的数即为质数。
优化遍历范围：外层循环仅需遍历到√n，因为若n为合数，则其必有一个因子小于等于√n。因为所有合数的最小质因子 ≤√n，因此它们的倍数已被处理。当外层循环遍历到 i = √n 时，所有以 i 为最小质因数的合数 j = i * k（其中 k ≥ i）都会被标记为合数。
此时，所有小于等于 n 的合数已经被其最小质因数标记过，无需再处理更大的 i。
减少重复标记：内层循环从i²开始标记倍数，避免重复处理较小倍数。埃氏筛法的外层循环按顺序遍历质数 i。当处理到质数 i 时，所有比 i 小的质数已处理完毕。当外层循环到达 i 时，i²是第一个未被标记的合数。如下图。----- 例如：i为4时，本应该用（4*2, 4*3,） 4*4, 4*5, 4*6...直到n为止，而4*2,4*3都已被i为2中的：2*2，2*3，2*4；i为3中的：（3*2，）3*3，3*4包含。

具体实现：

初始化list数组：创建list集合，将0-n传递到list中。
外层循环遍历：从2到√n，若当前数i为质数，则标记其所有倍数为非质数。如下图所示。

此图片为转载

收集结果：遍历集合，收集所有值为!=0的值的数作为质数。

代码：

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class 埃氏筛 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Scanner sc=new Scanner(System.in);
		int n=sc.nextInt();
		
		List<Integer>li=new ArrayList<>();
		li.add(0);
		for(int i=1;i<=n;i++) {
			li.add(i);
		}
		li.set(1, 0);
//假设所有数都是质数，然后从最小的质数2开始，依次标记其倍数为非质数，剩余未被标记的数即为质数。
		for(int i=2;i*i<=n;i++) {//外层循环仅需遍历到√n，因为若n为合数，则其必有一个因子小于等于√n。
			if(li.get(i)!=0) {
				for(int j=i*i;j<=n;j+=i) {//内层循环从i²开始标记倍数，避免重复处理较小倍数。
					li.set(j, 0);//将所有i的倍数记为合数（非素数）。
				}
			}
		}
		for(int i=2;i<=n;i++) {
			if(li.get(i)!=0) {
				System.out.println(i);
			}
		}
	}
}

优化：

1.改用布尔数组：

boolean[] isPrime = new boolean[n+1];
Arrays.fill(isPrime, true);
isPrime[0] = isPrime[1] = false;

2.整数溢出风险：

问题原因：
当 i 较大时（例如 i=46341），i*i 会超过 Integer.MAX_VALUE（即 2^31-1），导致 j 变为负数，引发错误标记。

修正方法：
将 i 的类型改为 long，或调整判断条件：

for (int j = i * i; j <= n && j > 0; j += i) {  // 增加j>0判断
    li.set(j, 0);
}

优化后：

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class 埃氏筛 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        
        // 使用布尔数组优化
        boolean[] isPrime = new boolean[n + 1];
        Arrays.fill(isPrime, true);
        isPrime[0] = isPrime[1] = false;

        // 外层循环遍历到√n
        for (int i = 2; i * i <= n; i++) {
            if (isPrime[i]) {
                // 内层循环避免溢出
                for (int j = i * i; j <= n && j > 0; j += i) {//i*i 可能超出整型范围，用j>0防止溢出后仍进行此代码
                    isPrime[j] = false;
                }
            }
        }

        // 收集结果
        for (int i = 2; i <= n; i++) {
            if (isPrime[i]) {
                System.out.println(i);
            }
        }
    }
}