java输出1~100之间的全部素数的5种方法

原创 已于 2023-03-30 12:39:17 修改 · 6.4w 阅读 · 263 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java求100以内的素数

于 2019-07-02 15:55:36 首次发布
本文介绍五种使用Java计算1至100范围内素数的方法，包括根据定义遍历检查、利用数学条件优化遍历次数及数组筛选等策略，旨在提高算法效率。

文章目录

一、前言

在我们面试或者初学java 会遇到 请用java输出1~100的所有素数，这样一道问题，这道题有很多的解法，接下来我们将讲解其中的 5种方案:

二、需求分析

2.1 . 什么是素数?

经查询小学二年级的数学课本可知：

  • 只能被1和本身整除的称为素数

2.2 分析

判断是不是素数的方法很多，但不外乎是循环嵌套外加条件语句； 故我们可以分析出以下判断条件：

  1. 判断条件1：只能被1和本身整除的称为素数；
  2. 判断条件2：在区间（1，x/2）中找不到能整除素数x的整数；
  3. 判断条件3：在区间（1，sqrt(x)）中找不到能整除素数x的整数；

三、代码实现

3.1 方法一：根据素数的定义来遍历检查

这种方案也是最简单，最容易想到的方法。

    /**
     * 方法一：根据素数的定义来遍历检查
     */
    private static void method1() {

//外层循环遍历被除数i(因为1既不是素数也不是和数，所以直接从2开始遍历)
        for (int i = 2; i <= 100; i++) {
//定义一个逻辑值，初值为true
            boolean flag = true;
//内层遍历除数j
            for (int j = 2; j < i; j++) {
//判断是否存在j能整除i，若存在，则更改flag的值并跳出循环
                if (0 == i % j) {
                    flag = false;
                    break;
                }
            }
//根据flag的值判断是否输出i
            if (flag) {
                System.out.print(i + " ");
            }
        }
        System.out.println('\n' + "---------------------------");
    }

3.2 方法二：根据判断条件2进行遍历检查，减少遍历次数

    /**
     * 方法二：根据判断条件2进行遍历检查，减少遍历次数
     * 外层循环遍历被除数i(因为1既不是素数也不是和数，所以直接从2开始遍历)
     */
    private static void method2() {

        for (int i = 2; i <= 100; i++) {
            //定义一个逻辑值flag，初始值为true
            boolean flag = true;
            //内层循环遍历除数j(注意：此处若不取边界，则当i=4时，j=2会因为小于i/2=2而直接跳出内循环)
            for (int j = 2; j <= (i / 2); j++) {
                //判断是否存在除数j能整除i，若存在，则修改flag的值并跳出循环
                if (0 == i % j) {
                    flag = false;
                    break;
                }
            }
            //根据flag的值判断是否输出i
            if (flag) {
                System.out.print(i + " ");
            }
        }
        System.out.println('\n' + "---------------------------");
    }

3.3 方法三：根据判断条件3进行遍历检查，减少遍历次数

    /**
     * 方法三：根据判断条件3进行遍历检查，减少遍历次数
     * 外层循环遍历被除数i(因为1既不是素数也不是和数，所以直接从2开始遍历)
     */
    private static void method3() {

        for (int i = 2; i <= 100; i++) {
//定义一个逻辑值flag，初始值为true
            boolean flag = true;
//内层循环遍历除数j(注意：此处若不取边界，则当i=4时，j=2会因为小于sqrt(i)=2而直接跳出内循环)
//再思考一下若i=25时呢？若不取边界还有那些不是素数的数会输出呢？
            for (int j = 2; j <= Math.sqrt(i); j++) {
//判断是否存在除数j能整除i，若存在，则修改flag的值并跳出循环
                if (0 == i % j) {
                    flag = false;
                    break;
                }
            }
//根据flag的值判断是否输出i
            if (flag) {
                System.out.print(i + " ");
            }
        }
        System.out.println('\n' + "---------------------------");
    }

3.4 方法四：在方法三的前提上优化，优化基础是除2外的所有偶数均不是素数

    /**方法四：在方法三的前提上优化，优化基础是除2外的所有偶数均不是素数，
     *(i+=2)只遍历奇数，减少外层遍历次数；同理，由于奇数是不能被偶数整除的，
     *(j+=2)只遍历奇数，减少内层遍历次数
     */
    private static void method4() {

        System.out.print("2 ");
        //外层循环遍历被除数i(因为1既不是素数也不是和数，所以直接从2开始遍历)
        for (int i = 3; i <= 100; i += 2) {
            //定义一个逻辑值flag，初始值为true
            boolean flag = true;
            //内层循环遍历除数j(注意：此处若不取边界，则当i=4时，j=2会因为小于sqrt(i)=2而直接跳出内循环)
            //再思考一下若i=25时呢？若不取边界还有那些不是素数的数会输出呢？
            for (int j = 3; j <= Math.sqrt(i); j += 2) {
                //判断是否存在除数j能整除i，若存在，则修改flag的值并跳出循环
                if (0 == i % j) {
                    flag = false;
                    break;
                }
            }
            //根据flag的值判断是否输出i
            if (flag) {
                System.out.print(i + " ");
            }
        }
        System.out.println('\n' + "---------------------------");
    }

3.5 方案五：优化更长的素数计算

联想一下，能被2整除（偶数）的直接剔除，同样的道理，能被3or5整除的剔除掉会不会让外层循环的次数更少呢？此处才到100，若是1000呢？10000呢？定义一个数组，由于剔除了偶数，故数组长度不会超过总个数的一半。

    /**
     * 联想一下，能被2整除（偶数）的直接剔除，同样的道理，能被3or5整除的剔除掉会不会让外层循环的次数更少呢？
     * 此处才到100，若是1000呢？10000呢？
     * 定义一个数组，由于剔除了偶数，故数组长度不会超过总个数的一半
     */
    private static void method5() {
        int[] arr = new int[500];
        int count = 0;
        for (int i = 6; i <= 1000; i++) {
            boolean flag = true;
            if (0 == i % 2 || 0 == i % 3 || 0 == i % 5) {
                flag = false;
            }

            if (flag) {
                arr[count] = i;
                count++;
            }
        }
        System.out.println("6~1000中剔除能被2or3or5整除的数后还剩" + count + "个");
        System.out.println("1~1000中所有素数为：");
        System.out.print("2" + "\t");
        System.out.print("3" + "\t");
        System.out.print("5" + "\t");
        count = 0;
        for (int i = 0; i < 500; i++) {
            boolean flag = true;
            if (0 == arr[i]) {
                break;
            }

            for (int j = 7; j <= Math.sqrt(arr[i]); j += 2) {
                if (0 == (arr[i]) % j) {
                    flag = false;
                    break;
                }
            }
            if (flag) {
                System.out.print((arr[i]) + "\t");
                count++;
            }
        }
        System.out.println("\n" + "---------------------");
        System.out.println("\n" + "其中6~1000中剔除能被2or3or5整除的数中还是素数的有" + count + "个");
    }

四、完整的代码实现

package com.ratel.skywalking.order;
/*
分析：
1.素数：
判断条件1：只能被1和本身整除的称为素数；
判断条件2：在区间（1，x/2）中找不到能整除素数x的整数；
判断条件3：在区间（1，sqrt(x)）中找不到能整除素数x的整数；
2.方法：很多，但不外是循环嵌套外加条件语句；
*/
class PrintSuShu {
    public static void main(String[] args) {
        method1();
        method2();
        method3();
        method4();
        method5();


    }

    /**
     * 联想一下，能被2整除（偶数）的直接剔除，同样的道理，能被3or5整除的剔除掉会不会让外层循环的次数更少呢？
     * 此处才到100，若是1000呢？10000呢？
     * 定义一个数组，由于剔除了偶数，故数组长度不会超过总个数的一半
     */
    private static void method5() {
        int[] arr = new int[500];
        int count = 0;
        for (int i = 6; i <= 1000; i++) {
            boolean flag = true;
            if (0 == i % 2 || 0 == i % 3 || 0 == i % 5) {
                flag = false;
            }

            if (flag) {
                arr[count] = i;
                count++;
            }
        }
        System.out.println("6~1000中剔除能被2or3or5整除的数后还剩" + count + "个");
        System.out.println("1~1000中所有素数为：");
        System.out.print("2" + "\t");
        System.out.print("3" + "\t");
        System.out.print("5" + "\t");
        count = 0;
        for (int i = 0; i < 500; i++) {
            boolean flag = true;
            if (0 == arr[i]) {
                break;
            }

            for (int j = 7; j <= Math.sqrt(arr[i]); j += 2) {
                if (0 == (arr[i]) % j) {
                    flag = false;
                    break;
                }
            }
            if (flag) {
                System.out.print((arr[i]) + "\t");
                count++;
            }
        }
        System.out.println("\n" + "---------------------");
        System.out.println("\n" + "其中6~1000中剔除能被2or3or5整除的数中还是素数的有" + count + "个");
    }

    /**方法四：在方法三的前提上优化，优化基础是除2外的所有偶数均不是素数，
     *(i+=2)只遍历奇数，减少外层遍历次数；同理，由于奇数是不能被偶数整除的，
     *(j+=2)只遍历奇数，减少内层遍历次数
     */
    private static void method4() {

        System.out.print("2 ");
        //外层循环遍历被除数i(因为1既不是素数也不是和数，所以直接从2开始遍历)
        for (int i = 3; i <= 100; i += 2) {
            //定义一个逻辑值flag，初始值为true
            boolean flag = true;
            //内层循环遍历除数j(注意：此处若不取边界，则当i=4时，j=2会因为小于sqrt(i)=2而直接跳出内循环)
            //再思考一下若i=25时呢？若不取边界还有那些不是素数的数会输出呢？
            for (int j = 3; j <= Math.sqrt(i); j += 2) {
                //判断是否存在除数j能整除i，若存在，则修改flag的值并跳出循环
                if (0 == i % j) {
                    flag = false;
                    break;
                }
            }
            //根据flag的值判断是否输出i
            if (flag) {
                System.out.print(i + " ");
            }
        }
        System.out.println('\n' + "---------------------------");
    }

    /**
     * 方法三：根据判断条件3进行遍历检查，减少遍历次数
     * 外层循环遍历被除数i(因为1既不是素数也不是和数，所以直接从2开始遍历)
     */
    private static void method3() {

        for (int i = 2; i <= 100; i++) {
//定义一个逻辑值flag，初始值为true
            boolean flag = true;
//内层循环遍历除数j(注意：此处若不取边界，则当i=4时，j=2会因为小于sqrt(i)=2而直接跳出内循环)
//再思考一下若i=25时呢？若不取边界还有那些不是素数的数会输出呢？
            for (int j = 2; j <= Math.sqrt(i); j++) {
//判断是否存在除数j能整除i，若存在，则修改flag的值并跳出循环
                if (0 == i % j) {
                    flag = false;
                    break;
                }
            }
//根据flag的值判断是否输出i
            if (flag) {
                System.out.print(i + " ");
            }
        }
        System.out.println('\n' + "---------------------------");
    }

    /**
     * 方法二：根据判断条件2进行遍历检查，减少遍历次数
     * 外层循环遍历被除数i(因为1既不是素数也不是和数，所以直接从2开始遍历)
     */
    private static void method2() {

        for (int i = 2; i <= 100; i++) {
            //定义一个逻辑值flag，初始值为true
            boolean flag = true;
            //内层循环遍历除数j(注意：此处若不取边界，则当i=4时，j=2会因为小于i/2=2而直接跳出内循环)
            for (int j = 2; j <= (i / 2); j++) {
                //判断是否存在除数j能整除i，若存在，则修改flag的值并跳出循环
                if (0 == i % j) {
                    flag = false;
                    break;
                }
            }
            //根据flag的值判断是否输出i
            if (flag) {
                System.out.print(i + " ");
            }
        }
        System.out.println('\n' + "---------------------------");
    }

    /**
     * 方法一：根据素数的定义来遍历检查
     */
    private static void method1() {

//外层循环遍历被除数i(因为1既不是素数也不是和数，所以直接从2开始遍历)
        for (int i = 2; i <= 100; i++) {
//定义一个逻辑值，初值为true
            boolean flag = true;
//内层遍历除数j
            for (int j = 2; j < i; j++) {
//判断是否存在j能整除i，若存在，则更改flag的值并跳出循环
                if (0 == i % j) {
                    flag = false;
                    break;
                }
            }
//根据flag的值判断是否输出i
            if (flag) {
                System.out.print(i + " ");
            }
        }
        System.out.println('\n' + "---------------------------");
    }
}
用java求100以内的所有素数（素数：一个大于1的自然数，除了1和它本身外，不能被其他自然数整除）
Zyf15156243165的博客
09-06 2808
求100以内的所有素数 （素数：一个大于1的自然数，除了1和它本身外，不能被其他自然数整除）
java代码-求1到100里面的素数
07-16
java代码-求1到100里面的素数
【Java】求1-100范围内的素数递归方法
11-11
【Java】求1-100范围内的素数递归方法代码例子。分享，感谢。
Java实现素数判断的三种高效算法详解与实战
最新发布
weixin_28840811的博客
11-02 880
素数（Prime Number）是指大于1的自然数中，除了1和它本身之外没有其他正因数的数。形式化定义为：若整数 $ p > 1 $，且其正因数仅有1和 $ p $，则称 $ p $ 为素数。这一简单定义背后蕴含深刻的数论意义——素数是构成所有自然数的“原子单元”，根据算术基本定理，任一大于1的整数均可唯一分解为有限个素数的乘积。在实际判定过程中，关键难点在于如何高效验证“无其他因数”。最朴素的方法是试除法：检查从2到 $ \sqrt{n} $ 的所有整数是否能整除 $ n $。
java之求1到100之间的所有素数
m0_56606118的博客
05-22 6937
//求1道100的所有素数 public class Example1_4 { public static void main(String[] args) { for (int i = 1; i <= 100; i++) {//从1到100，作为第一次循环 for (int z = 2; z <100; z++) {//从2开始到100，剔除1这个问题数子 if(i%z==0&&i!=z){.
java 求1-100的素数
foutousen的专栏
04-10 645
一、openfire官方下载
Java——求1-100之间的素数个数并输出每一个素数（区间可任意更改）
钢铁大侠的博客
03-25 4468
素数又叫质数，就是除了1和它本身之外，再也没有整数能被它整除的数。也就是素数只有两个因子。
java输出1~100之间的全部素数
09-13
在Java中，输出1到100之间的所有素数可以通过编写一个程序来实现。素数是指只能被1和它本身整除的数，且必须大于1。下面是一个简单的Java程序示例，用于输出1到100之间的所有素数： ```java public class Prime...
java求100之内的素数(质数)简单示例
09-04
Java编程语言提供了一种简单的方法来寻找100以内的所有素数。素数，也称为质数，是大于1的自然数，除了1和它自身以外，不能被其他自然数整除。如果一个数可以被其他自然数整除，那么它被称为合数。 根据算术基本...
Java列出2到100之间所有素数的方法
09-03
这段代码执行后，将依次输出2到100之间的所有素数，如2、3、5、7、11、13等。这个过程利用了Java的循环和条件语句，以及数学上的素数性质。通过这种方式，我们可以轻松地找出一个指定范围内的所有素数，对于理解和...
用java输出200~400之间的素数每行5个
03-23
以下是Java代码，可以输出200~400之间的素数每行5个： ```java public class PrimeNumbers { public static void main(String[] args) { int count = 0; for (int i = 200; i ; i++) { if (isPrime(i)) { ...
使用java代码实现输出0~100之间的素数
05-25
以下是使用 Java 代码输出 0~100 之间的素数： ```java public class PrimeNumbers { public static void main(String[] args) { int i, j; boolean isPrime; for (i = 0; i <= 100; i++) { if (i == 0 || i ...
java求100以内的素数
热门推荐
qq_44297220的博客
11-24 2万+
找出1-100之间所有的素数（质数） 第一种方法： 如何判断i是否是素数 （1）找出i的所有的约数，并累加它们的和 例如： i=5，它的约数有1和5，约数和：6 i=11，它的约数有1和11，约数和：12 i=18，它的约数有1,2,3,6,9,18，约数和：39 （2）如果某个i的约数和 == i+1，那么i就是素数 class PrimeIn_100_1{ public static void main(String[] args){ //找出1-100之间所有的素
Java求1到100内的素数
qq_48412264的博客
10-21 1497
public class sushu { public static void main(String[] args) { //求1到100内的素数，只有1和它本身可以被整除 System.out.println("1");//输出1 System.out.println("2");//输出2 //从三开始一个一个判断是否为素数 for(int i=3;i<=100;i++) { ...
用Java求1到100的素数
weixin_66407850的博客
05-10 1824
Java1到100的素数
Java求100以内的全部素数
Eihjteen的博客
10-03 1809
java编写，求100以内的全部素数。 刚开始写博客，如果有什么错误大家可以提出来，我们可以一起探讨。 public class java5{ public static void main(String args[]){ int i,j; for(i=1;i<=100;i++){ if(i%2==0||i%3==0||i%5==0) System.out.print("")...
编写一个Java应用程序求100以内的全部素数。
2301_77127201的博客
09-26 1247
编写一个Java应用程序来求100以内的全部素数，可以通过遍历2到99之间的所有数，并对每个数检查它是否是素数来实现。方法中，我们首先检查数字是否小于2，因为小于2的数不是素数。然后，我们使用一个循环从2遍历到该数的平方根（包含），检查是否有任何数能整除它。如果找到这样的数，则该方法返回。方法，该方法接收一个整数作为参数，并返回一个布尔值，表示该整数是否是素数。，表示该数不是素数。如果循环完成而没有找到任何能整除的数，则该方法返回。方法中，我们遍历2到99之间的所有数，并对每个数调用。
Java程序：求100以内的全部素数
weixiubo10086的博客
03-05 270
【代码】Java程序：求100以内的全部素数。
c语言1到100素数个数
10-23
可以使用以下几种方法来实现使用C语言计算1到100素数的个数： ### 方法一 ```c #include <stdio.h> int prime(int m) { int n; for (n = 2; n < m; n++) { if (m % n == 0) { return 0; } } return 1; } int main() { int i; int count = 0; for (i = 2; i < 100; i++) { if (prime(i) != 0) { count++; } } printf("1到100之间素数的个数为: %d\n", count); return 0; } ``` 此方法定义了一个判断素数的函数`prime`，在`main`函数中遍历2到99的数，调用`prime`函数判断是否为素数，若是则计数器`count`加1，最后输出素数的个数[^1]。 ### 方法二 ```c #include <stdio.h> int main() { int i, j, sign; int count = 0; for (i = 2; i <= 100; i++) { sign = 0; for (j = 2; j < i; j++) { if (i % j == 0) { sign = 1; break; } } if (sign == 0) { count++; } } printf("1到100之间素数的个数为: %d\n", count); return 0; } ``` 该方法在`main`函数中，使用两层循环，外层循环遍历2到100的数，内层循环判断该数是否有除1和自身以外的因数，若有则标记`sign`为1，若`sign`为0则说明是素数，计数器`count`加1，最后输出素数个数[^2]。 ### 方法三 ```c #include <stdio.h> int main() { int a = 0; int d = 0; for (a = 2; a <= 100; a++) { int b = 0; int c = 1; for (b = 2; b < a; b++) { if (a % b == 0) { c = 0; break; } } if (c == 1) { d++; } } printf("1到100之间素数的个数为: %d\n", d); return 0; } ``` 此方法同样使用两层循环，外层循环遍历2到100的数，内层循环判断该数是否为素数，若为素数则将标记`c`设为1，最后根据`c`的值决定是否将计数器`d`加1，最终输出素数个数[^3]。 ### 方法四 ```c #include <stdio.h> #include <math.h> #define N 101 int main() { int i, j; int count = 0; int a[N]; for (i = 2; i < N; i++) a[i] = i; for (i = 2; i < sqrt(N); i++) for (j = i + 1; j < N; j++) { if (a[i] != 0 && a[j] != 0) if (a[j] % a[i] == 0) a[j] = 0; } for (i = 2; i < N; i++) { if (a[i] != 0) { count++; } } printf("1到100之间素数的个数为: %d\n", count); return 0; } ``` 这种方法使用了埃拉托斯特尼筛法，先将2到100的数存入数组`a`，然后从2开始，将其倍数标记为0，最后统计数组中不为0的数的个数，即为素数的个数，最后输出素数个数[^5]。
评论 10
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

T-OPEN

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值