1. 
   
2. public class Sushu {
   
3. 
   
4.         /**
   
5.          * @param args
   
6.          */
   
7.         public static void main(String[] args) {
   
8.                 // TODO Auto-generated method stub
   
9.      //打印1-200以内的素数（素数只能被1和自身整除的数）
   
10.                 boolean flag=true;
    
11.                
    
12.                 for(int n=2;n<=200;n++){
    
13.                         //判断是否为素数
    
14.                         for(int i=2;i<n;i++){
    
15.                                 if(n%i==0){
    
16.                                         flag=false;
    
17.                                        
    
18.                                         break;
    
19.                                        
    
20.                                 }               
    
21.                         }
    
22.                         if(flag){
    
23.                                 //输出素数
    
24.                                         System.out.println(n+"<--是素数");
    
25.                                 }
    
26.                                        
    
27.                 }
    
28.          }
    
29.         }
    
30.        
    
31. 
    
32. 
    

复制代码

怎么输出结果只有2<--是素数
3<--是素数
求解答，怎么不是输出1-200以内的素数

1. <div class="blockcode"><blockquote>
   
2. public class SuShu
   
3. {
   
4. 
   
5.         public static void main(String[] args)
   
6.         {
   
7.              System.out.println("2");//2是个特殊的素数，我单独拿开。
   
8.      //打印1-200以内的素数（素数只能被1和自身整除的数）
   
9.                 for(int x=3;x<=200;x+=2)//我从3开始算起，只算奇数。大家都知道偶数肯定不是素数。
   
10.                 {
    
11.                         boolean b=true;
    
12.                         for(int y=2;y<=x/2;y++)
    
13.                         {
    
14.                                 if(x%y==0)
    
15.                                 {
    
16.                                         b=false;
    
17.                                         break;
    
18.                                
    
19.                                 }
    
20.                                
    
21.                         }
    
22.                         if(b)
    
23.                         {
    
24.                                
    
25.                                 System.out.println(x);
    
26.                         }
    
27.                 }   
    
28.          }
    
29. }
    
30.         

复制代码

我将你代码改了下 你可以看看错哪里了.我的直接拿奇数去判断，偶数就不去算了，毕竟偶数都是可以被2整除的。这算不算优化。

1.   boolean flag = true;
   
2.             
   
3.   //判断是否为素数
   
4.   for(int i = 2; i < n; i++) {
   
5.          flag = true;                   //   <- 加上这条语句
   
6.           if(n % i == 0) {
   
7.                 flag = false;
   
8.                 break;
   
9.            }               
   
10.    }
    

复制代码

在for循环第一句加上一句flag = true;就行了，因为你判断4不是素数后，flag还是false，再去判断5也不会变成true，所以要先恢复flag的值。

1. public class Sushu {
   
2. 
   
3.         /**
   
4.          * @param args
   
5.          */
   
6.         public static void main(String[] args) {
   
7.                 // TODO Auto-generated method stub
   
8.      //打印1-200以内的素数（素数只能被1和自身整除的数）
   
9.                
   
10.                
    
11.                 for(int n=2;n<=200;n++){
    
12.                         //判断是否为素数
    
13.                         boolean flag = true;
    
14.                         for(int i=2;i<n/2;i++){
    
15.                                 flag=true;
    
16.                             if(n%i==0){
    
17.                                     flag=false;                             
    
18.                                     break;                                 
    
19.                             }  
    
20.                         }
    
21.                         if(flag){
    
22.                                 //输出素数
    
23.                                     System.out.println(n+"<--是素数");
    
24.                             }
    
25.                                        
    
26.                 }
    
27.          }
    
28.         }

复制代码

原因：循环之后flag未初始化(flag=false后未初始化为TRUE导致之后的循环失败)
顺便指出一个错误：素数的计算，内循环应为for(int i=2;i<n/2;i++)

照你原先的代码和楼上计算，“4”也被计算为素数（1楼把“2”漏掉了）

在你原有上改了一下   试过了


public class Sushu {

        /**
         * @param args
         */
        public static void main(String[] args) {
                // TODO Auto-generated method stub
     //打印1-200以内的素数（素数只能被1和自身整除的数）
                boolean flag=false;///////////////////////////////////////////////////这改了
               
                for(int n=2;n<=200;n++){
                        //判断是否为素数
                        for(int i=2;i<n;i++){
                                if(n%i==0){
                                        flag=true;、、、、、、、、、、、、、、、、、、、、、、、、这改了
                                            break;
                                                      }
                                                
                        }
                                                
                        if(!flag){、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、这改了
                                //输出素数
                                        System.out.println(n+"<--是素数");
                                }
                                 flag=false;      
                }
         }
        }

在你的源码基础上修改的   你看看

public class Sushu {

        public static void main(String[] args) {
                // TODO Auto-generated method stub
                // 打印1-200以内的素数（素数只能被1和自身整除的数）
                boolean flag = true;
                for (int n = 2; n <= 200; n++) {
                        // 判断是否为素数
                        for (int i = 2; i < n; i++) {
                                if (n % i == 0) {
                                        flag = false;
                                        break;
                                } else {
                                        flag = true;
                                }
                        }
                        if (flag) {
                                // 输出素数
                                System.out.println(n + "<--是素数");
                        }

                }
        }
}

这是求1~100以内所有数的素数因子，也是求素数的，给你加强训练一下。{:soso_e113:}{:soso_e113:}{:soso_e113:}{:soso_e113:}{:soso_e113:}{:soso_e113:}{:soso_e113:}{:soso_e113:}{:soso_e113:}{:soso_e113:}

1. //24的素数因子有：2，3，
   
2. //25的素数因子有：5，
   
3. //26的素数因子有：2，13，
   
4. //27的素数因子有：3，
   
5. //28的素数因子有：2，7，
   
6. //29的素数因子有：
   
7. //30的素数因子有：2，3，5，
   
8. public class Prime {
   
9.         public static boolean zhishu (int a){
   
10.                 for (int i=2;i<a;i++){
    
11.                         if (a%i==0){
    
12.                                 return false;
    
13.                         }
    
14.                 }return true;
    
15.         }       
    
16.         public static void main(String[] args) {
    
17.                 for (int i=2;i<101;i++){
    
18.                         for (int j=2;j<i;j++){
    
19.                                 if (i%j==0&&zhishu(j)){
    
20.                                         System.out.println(i+"素数因子  "+j);       
    
21.                                 }
    
22.                         }
    
23.                 }//System.out.println();
    
24.         }
    
25. }

复制代码

看到这题目，自己打了一遍代码，

1. class sushuDemo
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.         sushu s1=new sushu(1,200);//自己定义范围是1-200
   
6.         s1.ssmuch();
   
7.         }
   
8. }
   
9. class sushu
   
10. {
    
11.         int[] sushu;
    
12.         int x,y;
    
13.         sushu(int x,int y)
    
14.                 {
    
15.                         this.x=x;
    
16.                         this.y=y;
    
17.                 }
    
18.                 //素数是只能被自己和一整除的数
    
19.                 public void ssmuch()
    
20.                         {
    
21.                                 for(;x<=y;x++)
    
22.                                         {
    
23.                        
    
24.                                                 //这里如果为真，则输出该数
    
25.                                                 if(panduan(x,y))        System.out.print(x+"\t");
    
26.                                         }
    
27.                         }
    
28.                 //这里是判断是否为素数的方法
    
29.                 public boolean panduan(int temp,int max)
    
30.                 {
    
31.                         for(int i=2;i<=max;i++)
    
32.                                 {
    
33.                                         if(temp%i!=0)continue;
    
34.                                         else if(temp==2||i==temp)//2是特别的素数，所以把它加上和能被自己整除的数算上
    
35.                                                 {continue;}
    
36.                                                 return false;
    
37.                                         }return true;
    
38.                 }
    
39. }

复制代码

谢谢了，我已经该对了