如何用Java写求小于n的最大素数

用Java写求小于n的最大素数，可以使用筛选法、递减检查法、并行计算。其中，筛选法（埃拉托斯特尼筛法）是最常用且高效的方法。具体实现方法如下：

筛选法（埃拉托斯特尼筛法）：这种方法通过从2开始，将每个素数的倍数都标记为非素数，最终剩下的未标记的数即为素数。这个方法的时间复杂度为O(n log log n)，是一种很高效的算法，特别适用于求解小于n的所有素数。

一、筛选法（埃拉托斯特尼筛法）

埃拉托斯特尼筛法是一种高效的找素数的方法。具体实现步骤如下：

初始化一个布尔数组：创建一个布尔数组 isPrime，长度为 n，初始全为 true。数组的索引表示数字，对应的布尔值表示该数字是否为素数。
从最小素数开始筛选：从2开始，标记所有2的倍数为 false，然后到下一个未被标记的数字，标记其所有倍数为 false，依此类推，直到平方根为止。
找到最大素数：从 n-1 开始向下遍历，找到第一个布尔值为 true 的索引，这个索引即为小于 n 的最大素数。

public class LargestPrime {
    public static int largestPrimeLessThanN(int n) {
        if (n <= 2) {
            return -1; // 没有小于2的素数
        }
        boolean[] isPrime = new boolean[n];
        for (int i = 2; i < n; i++) {
            isPrime[i] = true;
        }
        for (int i = 2; i * i < n; i++) {
            if (isPrime[i]) {
                for (int j = i * i; j < n; j += i) {
                    isPrime[j] = false;
                }
            }
        }
        for (int i = n - 1; i >= 2; i--) {
            if (isPrime[i]) {
                return i;
            }
        }
        return -1; // 理论上不会到达这里
    }
    public static void main(String[] args) {
        int n = 100;
        System.out.println("小于 " + n + " 的最大素数是: " + largestPrimeLessThanN(n));
    }
}

二、递减检查法

递减检查法是一种简单但效率较低的方法。具体实现步骤如下：

从 n-1 开始向下检查：从 n-1 开始依次检查每个数是否为素数。
判断素数：对每个数调用一个函数来判断其是否为素数。

public class LargestPrime {
    public static int largestPrimeLessThanN(int n) {
        if (n <= 2) {
            return -1; // 没有小于2的素数
        }
        for (int i = n - 1; i >= 2; i--) {
            if (isPrime(i)) {
                return i;
            }
        }
        return -1; // 理论上不会到达这里
    }
    private static boolean isPrime(int num) {
        if (num <= 1) {
            return false;
        }
        for (int i = 2; i <= Math.sqrt(num); i++) {
            if (num % i == 0) {
                return false;
            }
        }
        return true;
    }
    public static void main(String[] args) {
        int n = 100;
        System.out.println("小于 " + n + " 的最大素数是: " + largestPrimeLessThanN(n));
    }
}

三、并行计算（高级方法）

对于非常大的 n，可以考虑使用并行计算来加快素数筛选的过程。使用Java的并行流（Parallel Stream）可以在多核CPU上并行执行任务。

初始化布尔数组：与筛选法类似，初始化一个布尔数组 isPrime。
并行筛选：使用并行流对数组进行筛选。
找到最大素数：同样从 n-1 开始向下遍历，找到第一个布尔值为 true 的索引。

import java.util.Arrays;
import java.util.stream.IntStream;
public class LargestPrime {
    public static int largestPrimeLessThanN(int n) {
        if (n <= 2) {
            return -1; // 没有小于2的素数
        }
        boolean[] isPrime = new boolean[n];
        Arrays.fill(isPrime, true);
        isPrime[0] = isPrime[1] = false;
        IntStream.range(2, (int) Math.sqrt(n) + 1).parallel().forEach(i -> {
            if (isPrime[i]) {
                for (int j = i * i; j < n; j += i) {
                    isPrime[j] = false;
                }
            }
        });
        for (int i = n - 1; i >= 2; i--) {
            if (isPrime[i]) {
                return i;
            }
        }
        return -1; // 理论上不会到达这里
    }
    public static void main(String[] args) {
        int n = 100;
        System.out.println("小于 " + n + " 的最大素数是: " + largestPrimeLessThanN(n));
    }
}

四、优化和改进

1. 空间优化

埃拉托斯特尼筛法的一个缺点是它需要一个大小为 n 的布尔数组。对于非常大的 n，这可能会导致内存不足的问题。可以考虑使用“分段筛法”来减少内存占用。

2. 时间优化

对于时间要求非常高的应用，可以考虑使用更高级的算法，如“分段筛法”结合“轮筛法”。这两种方法可以显著提高筛选的效率。

3. 并行优化

可以使用Java的并行流来加快筛选过程。尽管并行流在某些情况下会带来开销，但对于非常大的 n，并行计算的优势会逐渐显现。

import java.util.Arrays;
import java.util.stream.IntStream;
public class LargestPrime {
    public static int largestPrimeLessThanN(int n) {
        if (n <= 2) {
            return -1; // 没有小于2的素数
        }
        boolean[] isPrime = new boolean[n];
        Arrays.fill(isPrime, true);
        isPrime[0] = isPrime[1] = false;
        IntStream.range(2, (int) Math.sqrt(n) + 1).parallel().forEach(i -> {
            if (isPrime[i]) {
                for (int j = i * i; j < n; j += i) {
                    isPrime[j] = false;
                }
            }
        });
        for (int i = n - 1; i >= 2; i--) {
            if (isPrime[i]) {
                return i;
            }
        }
        return -1; // 理论上不会到达这里
    }
    public static void main(String[] args) {
        int n = 1000000;
        System.out.println("小于 " + n + " 的最大素数是: " + largestPrimeLessThanN(n));
    }
}

五、结论

通过上面的几种方法，我们可以看到，埃拉托斯特尼筛法在大多数情况下是最优选择，尤其是对于中等规模的 n。对于特别大的 n，可以考虑使用分段筛法和并行计算来进一步优化。无论选择哪种方法，都需要根据具体的应用场景和性能要求来决定。