求三位数的质数，只能被本身和1整除！！！ 求解决啊 不会弄呢 没找到相关的呢

public class Test {

        public static void main(String[] args)
        {
                 //判断是否是质数。
                //三位质数从100开始到1000结束。
                for(int i = 100; i < 1000; i++ ) {  
                        
                        int factors = 0;  
                        
                        for(int j = 1; j < (i + 2)/2; j++ )
                        {  
                                // 将 i 依次除以 1 到 [(i + 2)/2]  
                                // 计算其整除的次数  
                                if((i % j) == 0) factors++;               
                        }  
                        // 如果只有一次整除，那么该数为素数  
                        if(factors < 2)   
                                System.out.println(i+"为质数");  
        }
      
              
  }
}

1. /*
   
2. *
   
3. * 思路：
   
4. *                 1.所有的三位质数，是指100-1000之间的质数，用循环语句取值
   
5. *                 2.判断数值是否为质数：设该数值为x，将x作为被模数，1~x的所有数值作为模数，进行模运算。
   
6. *                                                 结果为0的次数为2时，x即为质数。
   
7. * 步骤：       
   
8. *                 1.用for循环，遍历100-1000的数值。
   
9. *                 2.定义计数器，记录模运算结果为0 的次数
   
10. *                 3.嵌套for循环遍历1-x的数值，进行模运算，当结果为0时，计数器加1
    
11. *                 4.判断计数器的值，当值为2时，打印该数值。
    
12. *                 5.为方便查看结果，每打印10个数字进行一次换行。
    
13. */
    
14. package com.itheima;
    
15. 
    
16. /**
    
17. * @author 面具
    
18. */
    
19. public class Test5 {
    
20. 
    
21.         /**
    
22.          * @param args
    
23.          */
    
24.         public static void main(String[] args) {
    
25.                 // 调用函数，打印所有三位的质数
    
26.                 printPrime();
    
27.         }
    
28. 
    
29.         /**
    
30.          * 打印所有的三位质数。
    
31.          *
    
32.          * @param
    
33.          */
    
34.         public static void printPrime() {
    
35.                 // 定义变量记录打印的次数
    
36.                 int printCount = 0;
    
37. 
    
38.                 // 定义变量记录质数的个数，没找到一个质数该计数器+1
    
39.                 int primeCount = 0;
    
40. 
    
41.                 // for循环遍历100-1000的数值
    
42.                 for (int i = 100; i < 1000; i++) {
    
43.                         // 定义变量，记录模运算结果为0的次数
    
44.                         int count = 0;
    
45.                         // 取1~被模数之间的所有数值
    
46.                         for (int j = 1; j <= i; j++) {
    
47.                                 // 模运算，当结果为0时，计数器加1
    
48.                                 if (i % j == 0) {
    
49.                                         count++;
    
50.                                 }
    
51.                         }
    
52. 
    
53.                         // 对计数器的值进行判断，如果为2，打印该数字并将质数个数计数器加1
    
54.                         if (count == 2) {
    
55.                                 primeCount++;
    
56.                                 System.out.print(i + " ");
    
57.                                 printCount++;
    
58.                                 // 打印10个数值后进行换行
    
59.                                 if (printCount == 10) {
    
60.                                         System.out.println();
    
61.                                         printCount = 0;
    
62.                                 }
    
63.                         }
    
64.                 }
    
65.                 System.out.println();
    
66.                 System.out.println("三位的质数共计" + primeCount + "个");
    
67.         }
    
68. }
    

复制代码

//思想：用一个数分别去除2到sqrt(这个数)，如果能被整除，则表明此数不是质数，反之是质数。
class  ZhiShu
{
        public static void main(String[] args)
        {
                shuShu(101,200);//调用函数，传入两个数，判断这两个数中间有多少个质数
        }
        public static void shuShu(int x ,int y)//定义一个函数，判断两个数之间有多少个质数。
        {
                int count = 0;//定义一个变量，计数质数的个数
                for (int m=x; m<y ; m++)
                {
                        if(panDuan(m))//调用判断函数，判断该数是不是质数
                        {
                                System.out.print(m+" ");
                                count++;
                        }
                }
                System.out.println("count="+count);
        }
        private static boolean panDuan(int i)//定义一个判断函数，判断传入数是否为质数
        {
                for (int n = 2 ; n < i ; n++)
                {
                        if (i%n==0)
                        {
                                return false;
                        }
                }
                return true;
        }
}

class  Zhishu
{
        public static void main(String[] args)
        {
                int a=0;
                System.out.print("质数有：");
                for(int x=100;x<1000;x++)
                {
                        int z=0;
                        for(int y=1;y<=x;y++)
                        {
                                if(x%y==0)
                                {
                                        z++;
                                }
                        }
                        if(z==2)
                        {
                                System.out.print(x+",");
                                a++;
                        }
                }
                System.out.print("质数有："+a+"个");
        }
}

范围是三位质数从100开始到1000结束。 * 判断是否是质数，将 i 依次除以 1 到 [(i + 2)/2]， * 计算其整除的次数，如果只有一次整除，那么该数为素数。   public class Test7 {          public static void main(String[] args)          {                 zhishu();         }         public static void zhishu()         {                 //判断是否是质数。                 //三位质数从100开始到1000结束。                 for(int i = 100; i < 1000; i++ ) {                                                    int factors = 0;                                                    for(int j = 1; j < (i + 2)/2; j++ )                          {                                   // 将 i 依次除以 1 到 [(i + 2)/2]                                   // 计算其整除的次数                                   if((i % j) == 0) factors++;                                        }                           // 如果只有一次整除，那么该数为素数                           if(factors < 2)                                    System.out.println(i+"为质数");         }           } }

public void getZhiShu(){
                List<Integer> zhishuList = new ArrayList<Integer>();
                for (int i = 100; i < 1000; i++) {
                        int factors = 0;

                        for (int j = 2; j < Math.sqrt(i) + 1; j++) {
                                if (i % j == 0) {
                                        factors++;
                                }
                        }
                        if (factors == 0) {
                                zhishuList.add(i);
                        }
                }
                for (int k = 0; k < zhishuList.size(); k++) {
                        System.out.println(zhishuList.get(k) + "\t");
                }
                System.out.println("总个数为：" + zhishuList.size());
        }

楼上正解

wk843620202 发表于 2015-4-27 12:18
public void getZhiShu(){
                List zhishuList = new ArrayList();
                for (int i = 100; i < 1000; i++) {

我想知道那个内循环是什么意思

public class ZhiShu(){
   public static void main(String[] args){
            for(int i=100;i<=999;i++){
           int count=0;
           for(int j =2;j<i;j++){
              if(i%j==0){
        count++;
     break;
}
}
if(count==0){
    System.out.println(i);
}
}
}
}

public class Test12 {

        /**
         * 求三位数的质数，只能被 本身和1整除,倒序输出
         */
        public static void main(String[] args) {
                ArrayList<Integer> list = new ArrayList<>();
               
                boolean flag = true;
               
                for(int a = 100; a <= 999; a++) {
                        flag = true;
                        for(int b = 2; b < a; b++) {
                                if(a % b == 0) {
                                        flag = false;
                                       
                                        break;
                                }
                        }
                        if(flag) {
                                list.add(a);
                        }
                }
                Collections.reverse(list);
                System.out.println(list.toString());
        }

}