1. package com.itheima;
   
2. /**
   
3. *题目：
   
4. * 5、 编程打印所有的3位质数，质数特点：只能被1和其本身整除
   
5. *  *@author XXX
   
6. *  思路：审题，什么是质数，只能被自己和1整除。
   
7. *                 打印所有的三位质数，就是圈定了一个范围，打印所有的三位数的质数。范围在100与999之间。
   
8. *                 写个外循环循环这个三位数，内循环来判断是否是质数。
   
9. *                 内循环直接判断1到本身之间的数的取模，不考虑1和本身，模0，那么就做个标记。（后来发现不用，直接下一次外循环就 哦了。）
   
10. *                 内循环完，判断标记，如果是质数打印出来。
    
11. */
    
12. public class Test5 {
    
13.         public static void main (String[] args){
    
14.                 new ZhiShu();//第一次跟随思路写出的代码运行结果
    
15.                 new ZhiShu1();//简化完代码运行的结果
    
16.         }
    
17. }
    
18. //
    
19. class ZhiShu {
    
20.         ZhiShu (){
    
21.                 System.out.println("所有的三位质数有：");
    
22.                 //对100到999进行遍历
    
23.                 for(int num=100;num<1000;num++)
    
24.                 {
    
25.                         int Flg=0;//设置一个旗帜，用来简化代码。
    
26.                         //从1到本身之间取数，判断是否为质数。
    
27.                         b:for (int i=2;i<num;i++)
    
28.                         {
    
29.                                 //System.out.println(i);
    
30.                                 if((num % i) == 0)//取模,如果模为0，那么证明有数字可以整除。这个数不是质数。
    
31.                                  {
    
32.                                          Flg = 1;//对标志赋值，后面判断用
    
33.                                          break b;//跳出内循环
    
34.                                  }
    
35.                                 else
    
36.                                         Flg=0;//如果没有数可以整除，标志为0
    
37.                         }
    
38.                         if (Flg==0)//判断标志，为0就是质数进行打印
    
39.                         {
    
40.                                 System.out.print(num+" ");//由于数字比较多，那么就打印1排好了
    
41.                         }
    
42.                 }
    
43.                 System.out.println();
    
44.         }
    
45. 
    
46. }
    
47. /**突然想起来如果用continue，那么代码就会简单很多，省略了标志判断的过程。
    
48. * 简化完的代码，爽爆了。
    
49. */
    
50. class ZhiShu1 {
    
51.         ZhiShu1 (){
    
52.                 System.out.println("简化完代码后，所有的三位质数有：");
    
53.                 //对100到999进行遍历
    
54.                 a:for(int num=100;num<1000;num++)
    
55.                 {
    
56.                         //从1到本身之间取数，判断是否为质数。
    
57.                         for (int i=2;i<num;i++)
    
58.                         {
    
59.                                 //System.out.println(i);
    
60.                                 if((num % i) == 0)//取模,如果模为0，那么证明有数字可以整除。这个数不是质数。
    
61.                                  {
    
62.                                          continue a;//既然不是质数，后面的就不做了，进行下一次外循环。
    
63.                                  }
    
64.                         }
    
65.                         System.out.print(num+" ");//内循环计算完，证明这个数是质数。打印质数
    
66.                 }
    
67.                 System.out.println();
    
68.         }
    
69. 
    
70. }
    
71. 
    
72. 
    
73. 
    

复制代码

给自己顶一个，这个题目太简单了，但是呢，发现具有优化的可能。
当两个程序员比较的时候，有经验的人会用更简单和方便维护的方法写出更有效率的代码，这个应该就是经验了。

给楼主顶一个

顶一个！！！！！！

不错 ，加油

恩是的，代码要高效简洁。

不错楼主！

谢谢分享！

1. package cn.itcast.Test;
   
2. 
   
3. public class Test {
   
4.         public static void main(String[] args) {
   
5.                 int count = 0;
   
6.                 for (int i = 99; i <= 999; i++) {
   
7.                         for (int j = 1; j <= i; j++) {
   
8.                                 if (i % j == 0) {
   
9.                                         count++;
   
10.                                 }
    
11.                         }
    
12.                         if (count <= 2) {
    
13.                                 System.out.println(i);
    
14.                         }
    
15.                         count = 0;
    
16.                 }
    
17.         }
    
18. }
    

复制代码

我是这么写的  不知道对不对

顶一个。。。

优化后确实简单多了

a986875894 发表于 2015-2-14 09:23
我是这么写的  不知道对不对

我感觉还可以优一下，内循环可以只到i的平方根

顶一个。

a986875894 发表于 2015-2-14 09:23
我是这么写的  不知道对不对

首先，结果没有问题。就是觉得你的想法有点小误区，判断质数是使用整除法，那么只要1跟本身之间的数由一个可以整除就可以进行下一次了。你使用的方法是判断可以整除的个数。判断出来了也全部循环完毕了。
相比较而言效率较低。