用JAVA编写50以内的素数_java求50以内的素数

以下是使用Java编写的50以内的素数的程序：

public class PrimeNumbers {
    public static void main(String[] args) {
        int num = 50;
        System.out.println("Prime numbers up to " + num + " are:");
        for (int i = 2; i <= num; i++) {
            boolean isPrime = true;
            for (int j = 2; j <= i / 2; j++) {
                if (i % j == 0) {
                    isPrime = false;
                    break;
                }
            }
            if (isPrime) {
                System.out.print(i + " ");
            }
        }
    }
}

运行结果如下：

Prime numbers up to 50 are:
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 

相关问题

java编写应用程序求100以内的全部素数

### 回答1：
以下是Java编写的求100以内全部素数的应用程序：

public class PrimeNumbers {
    public static void main(String[] args) {
        int n = 100;
        boolean[] isPrime = new boolean[n + 1];
        for (int i = 2; i <= n; i++) {
            isPrime[i] = true;
        }
        for (int i = 2; i <= Math.sqrt(n); i++) {
            if (isPrime[i]) {
                for (int j = i * i; j <= n; j += i) {
                    isPrime[j] = false;
                }
            }
        }
        System.out.println("100以内的素数有：");
        for (int i = 2; i <= n; i++) {
            if (isPrime[i]) {
                System.out.print(i + " ");
            }
        }
    }
}

程序中使用了一个布尔数组`isPrime`，其中`isPrime[i]`表示数字`i`是否为素数。首先将数组中所有元素初始化为`true`，然后从2开始遍历数组，如果当前数字为素数，则将其倍数对应的数组元素设置为`false`，最后输出所有为`true`的元素即可。

运行程序，输出结果为：

100以内的素数有：
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 

### 回答2：
在Java中，要编写一个求100以内的所有素数的应用程序，我们可以利用 for 循环和嵌套循环的控制语句以及 if 判断语句来实现。

首先，我们定义一个变量 count 来计数，初始值为0。然后，我们使用 for 循环从2开始循环到100，依次判断每个数是否为素数。同时，我们使用嵌套循环，在内循环中判断当前数是否为素数。

素数是指只能被1和自身整除的自然数，那么，我们可以在内循环中从2开始到当前数的平方根为止循环，一旦发现当前数可以被任意一个数整除，就跳出循环，说明该数不是素数，否则，该数就是素数，输出该数并将 count 计数器加一。

代码如下：

public class PrimeNumber {
    public static void main(String[] args) {
        int count = 0;
        for (int i = 2; i <= 100; i++) {
            boolean flag = true;
            for (int j = 2; j <= Math.sqrt(i); j++) {
                if (i % j == 0) {
                    flag = false;
                    break;
                }
            }
            if (flag) {
                System.out.print(i + " ");
                count++;
            }
        }
        System.out.println("\n100以内的素数共有：" + count + "个");
    }
}

在上面的代码中，变量 flag 用来记录当前数是否为素数。它的初值为 true，如果找到能够整除当前数的数，就将其置为 false。如果当前数是素数，就输出该数并将计数器加1。最后，输出100以内的素数的个数。

执行上述代码，会得到以下输出结果：

2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 
100以内的素数共有：25个

可以看到，程序成功地求出了100以内的所有素数，并输出了它们的个数。

### 回答3：
素数是指除了1和本身以外，没有其它正整数能整除该数的数。求100以内的全部素数，可以使用JAVA编写应用程序来实现。

首先，定义一个函数isPrime来判断一个数是否为素数，该函数接受一个参数num，返回一个bool值，代表num是否为素数。函数实现如下：

public 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;
}

函数isPrime的实现思路是，当num小于等于1时，直接返回false，因为1不是素数。然后从2开始遍历到num开方，如果num能被i整除，则num不是素数，返回false。如果循环结束后仍未返回false，则说明num是素数，返回true。

然后，定义一个主函数main来输出100以内的全部素数。主函数的实现如下：

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

主函数从2开始遍历到100，对于每个数i，调用函数isPrime判断是否为素数，如果是素数则输出i。

最终，完整的JAVA代码如下：

public class PrimeNumber {
    public 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) {
        for (int i = 2; i <= 100; i++) {
            if (isPrime(i)) {
                System.out.println(i);
            }
        }
    }
}

运行程序后，可以得到输出结果为：

2
3
5
7
11
13
17
19
23
29
31
37
41
43
47
53
59
61
67
71
73
79
83
89
97

验证了程序的正确性，程序就实现了求100以内的全部素数。

java编写程序,求100以内的全部素数

下面是 Java 代码，用于找出 100 以内的所有素数：

public class PrimeNumbers {

    public static void main(String[] args) {
        int num = 100;
        boolean[] isPrime = new boolean[num+1];

        // 初始化数组
        for (int i = 2; i <= num; i++) {
            isPrime[i] = true;
        }

        // 找出素数
        for (int i = 2; i <= Math.sqrt(num); i++) {
            if (isPrime[i]) {
                for (int j = i*i; j <= num; j+=i) {
                    isPrime[j] = false;
                }
            }
        }

        // 输出素数
        System.out.println("Prime numbers from 1 to " + num + " are:");
        for (int i = 2; i <= num; i++) {
            if (isPrime[i]) {
                System.out.print(i + " ");
            }
        }
    }
}

代码中，我们使用一个布尔数组 `isPrime` 来存储每个数字是否为素数。首先，我们将数组中所有元素初始化为 `true`，然后从 2 开始遍历数组，将所有 2 的倍数、3 的倍数、4 的倍数……标记为非素数。最后，输出数组中所有值为 `true` 的元素，即为素数。

输出结果为：

Prime numbers from 1 to 100 are:
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97