public class Sushu {

        /**
         *判断 1 到200  之间的素数
         *算法：用一个数分别取除以2 到sqrt之间的数 如果可以被整除则不是素数 不可以被整除则是素数
         *分析：
         *双重for循环
         */
        public static void main(String[] args) {
                // TODO Auto-generated method stub
                int count = 1;
                System.out.println(2+"\t是素数");
                for(int i=3; i<200; i++){
                       
                        boolean flag = false;
                        for(int j=2; j<Math.sqrt(i); j ++){
                                        if( i%j == 0){
                                            flag = false;
                                                break;
                                                }
                                        else{
                                                        flag = true;
                                                       
                                                }
                                }
                        if(flag){
                                System.out.println(i+"\t是素数");
                                count ++;
                        }
                }
               
                System.out.println("素数个数是\t" +count);
        }

}

2        是素数
5        是素数
7        是素数
9        是素数
11        是素数
13        是素数
17        是素数
19        是素数
23        是素数
25        是素数
29        是素数
31        是素数
37        是素数
41        是素数
43        是素数
47        是素数
49        是素数
53        是素数
59        是素数
61        是素数
67        是素数
71        是素数
73        是素数
79        是素数
83        是素数
89        是素数
97        是素数
101        是素数
103        是素数
107        是素数
109        是素数
113        是素数
121        是素数
127        是素数
131        是素数
137        是素数
139        是素数
149        是素数
151        是素数
157        是素数
163        是素数
167        是素数
169        是素数
173        是素数
179        是素数
181        是素数
191        是素数
193        是素数
197        是素数
199        是素数
素数个数是        50

主要是有25 和 49

看看这段代码吧

1. public class exp2{
   
2.         public static void main(String args[]){
   
3.                 int i=0;
   
4.                 math mymath = new math();
   
5.                 for(i=2;i<=200;i++)
   
6.                         if(mymath.iszhishu(i)==true)
   
7.                         System.out.println(i);
   
8.         }
   
9. }
   
10. class math
    
11. {
    
12.         public boolean iszhishu(int x)
    
13.         {
    
14.                 for(int i=2;i<=x/2;i++)
    
15.                         if (x % 2==0 )
    
16.                                 return false;
    
17.                 return true;
    
18.         }
    
19. }
    

复制代码

1. 
   
2. public class Test {
   
3. 
   
4.         /**
   
5.          *判断 1 到200  之间的素数
   
6.          *算法：用一个数分别取除以2 到sqrt之间的数 如果可以被整除则不是素数 不可以被整除则是素数
   
7.          *分析：
   
8.          *双重for循环
   
9.          */
   
10.         public static void main(String[] args) {
    
11.                 // TODO Auto-generated method stub
    
12.                 int count = 1;
    
13.                 System.out.println(2+"\t是素数");
    
14.                 for(int i=3; i<200; i++){
    
15.                         
    
16.                         boolean flag = false;
    
17.                         for(int j=2; j <= Math.sqrt(i); j ++){   //小小的改变，程序是对的，注意细节
    
18.                                         if( i%j == 0){
    
19.                                             flag = false;
    
20.                                                 break;
    
21.                                                 }
    
22.                                         else{
    
23.                                                         flag = true;
    
24.                                                         
    
25.                                                 }
    
26.                                 }
    
27.                         if(flag){
    
28.                                 System.out.println(i+"\t是素数");
    
29.                                 count ++;
    
30.                         }
    
31.                 }
    
32.                
    
33.                 System.out.println("素数个数是\t" +count);
    
34.         }
    
35. 
    
36. }

复制代码

判断素数的方法：用一个数分别去除2到sqrt(这个数)，如果能被整除，   
则表明此数不是素数，反之是素数。
sqrt(49)是7，你没有把7算进去
sqrt(25)是5，你没有把7算进去

所以 for(int i=3; i<200; i++){  //这里i<=200


你的代码121,169，也都是错误答案。。 121=11*11   169 =13*13

检查一个正整数N是否为素数，最简单的方法就是试除法，将该数N用小于等于根号N的所有素数去试除，若均无法整除，则N为素数。你写的j<math.sqrt(i)没有等。改法有两种1加上等号2 j<math.sqrt(i)+1

1. public class Sushu
   
2.         {
   
3.                 public static void main(String[] args)
   
4.                         {
   
5.                                 int count = 1;
   
6.                                 System.out.println(2 + "\t是素数");
   
7.                                 for (int i = 3; i < 200; i++)
   
8.                                         {
   
9.                                                 boolean flag = false;
   
10.                                                 for (int j = 2; j < (int)Math.sqrt(i)+1; j++)
    
11.                                                         {
    
12.                                                                 if (i % j == 0)
    
13.                                                                         {
    
14.                                                                                 flag = false;
    
15.                                                                                 break;
    
16.                                                                         } else
    
17.                                                                         {
    
18.                                                                                 flag = true;
    
19.                                                                         }
    
20.                                                         }
    
21.                                                 if (flag)
    
22.                                                         {
    
23.                                                                 System.out.println(i + "\t是素数");
    
24.                                                                 count++;
    
25.                                                         }
    
26.                                         }
    
27. 
    
28.                                 System.out.println("素数个数是\t" + count);
    
29.                         }
    
30.         }

复制代码

判断语句 j<Math.sqrt(i)有错，Math.sqrt(i)是开平方根，25能直接开平方根得到Math.sqrt(i)=5，所以 if( i%j == 0)只能判断到j=4，可以在改i为j<Math.sqrt(i)+1 即可，49同理。PS：其实还是算法没理解到位，这里判断的依据是如果一个数不是素数，就肯定能被至2的倍数个不是1和本身数整除，例如24能被12X2；4X6整除，而其中一个数必然<=这个数的平方根，而不是只有小于，因为有刚好能平方根得到整数的情况，比如25，49等等。另外其实还可以这样简写代码，注意红色部分与你的代码区别class Sushu {

        /**
         *判断 1 到200  之间的素数
         *算法：用一个数分别取除以2 到sqrt之间的数 如果可以被整除则不是素数 不可以被整除则是素数
         *分析：
         *双重for循环
         */
        public static void main(String[] args) {
                // TODO Auto-generated method stub
                int count = 1;
                System.out.println(2+"\t是素数");
                for(int i=3; i<200; i++){

                        boolean flag = true;
                        for(int j=2; j<=Math.sqrt(i); j ++)
                                                        {
                                                        
                                      if( i%j == 0){
                                            flag = false;
                                                break;
                             }
                                            }
                        if(flag){
                                System.out.println(i+"\t是素数");
                                count ++;
                        }
                }

                System.out.println("素数个数是\t" +count);
        }

}