饭后一道题~天天好心情~

题目：判断101-200之间有多少个素数，并输出所有素数。

1. package day2;
   
2. 
   
3. import java.util.ArrayList;
   
4. import java.util.List;
   
5. 
   
6. /**
   
7. * 判断101-200之间有多少个素数，并输出所有素数。
   
8. *
   
9. * @author yellowbaby
   
10. *
    
11. */
    
12. public class Test {
    
13. 
    
14.         public static void main(String[] args) {
    
15. 
    
16.                 List<Integer> list = new ArrayList<Integer>();// 存放所有的素数
    
17. 
    
18.                 for (int num = 101; num <= 200; num++) {
    
19.                         isPrime(num, list);
    
20.                 }
    
21.                
    
22.                 System.out.println(list);
    
23.                 System.out.println("101-200之间素数的个数为:" + list.size());
    
24.         }
    
25. 
    
26.         /**
    
27.          * 判断是否是素数，素数的概念：指在一个大于1的自然数中，除了1和此整数自身外，不能被其他自然数整除的数
    
28.          */
    
29.         private static void isPrime(int num, List<Integer> list) {
    
30.                 for (int i = 2; i < num; i++) {
    
31.                         if(num % i == 0){
    
32.                                 return;
    
33.                         }
    
34.                 }
    
35.                 list.add(num);
    
36.         }
    
37. 
    
38. }
    
39. 
    

复制代码

呵呵，我的改动可是结构性的哦！不仅仅是代码的多少。{:soso_e113:}

丁旭 发表于 2012-10-18 01:04
我对您的代码做个小小的修改，看看这样可以吗？
我觉得您写的判断该数是否为素数的方法，返回值应为布尔型 ...

多谢捧场，我同意你的观点，但是从代码简洁性上来说，你的写法不是那么好~我改进了下~ 元芳，你怎么看？

1. package day2;
   
2. 
   
3. import java.util.ArrayList;
   
4. 
   
5. import java.util.List;
   
6. 
   
7. /**
   
8. *
   
9. * 判断101-200之间有多少个素数，并输出所有素数。
   
10. *
    
11. *
    
12. * @author yellowbaby
    
13. *
    
14. *
    
15. */
    
16. 
    
17. public class Test2 {
    
18. 
    
19.         public static void main(String[] args) {
    
20. 
    
21.                 List<Integer> list = new ArrayList<Integer>();// 存放所有的素数
    
22. 
    
23.                 for (int num = 101; num <= 200; num++) {
    
24.                         if (isPrime(num)) {
    
25.                                 list.add(num);
    
26.                         }
    
27.                 }
    
28. 
    
29.                 System.out.println(list);
    
30. 
    
31.                 System.out.println("101-200之间素数的个数为:" + list.size());
    
32. 
    
33.         }
    
34. 
    
35.         /**
    
36.          *
    
37.          * 判断是否是素数，素数的概念：指在一个大于1的自然数中，除了1和此整数自身外，不能被其他自然数整除的数
    
38.          */
    
39. 
    
40.         private static boolean isPrime(int num) {
    
41.                 for (int i = 2; i < num; i++) {
    
42.                         if (num % i == 0) {
    
43.                                 return false;
    
44.                         }
    
45.                 }
    
46.                 return true;
    
47.         }
    
48. }

复制代码

我对您的代码做个小小的修改，看看这样可以吗？
我觉得您写的判断该数是否为素数的方法，返回值应为布尔型更为合理。
当返回值为true时，就把这个数添加到集合中。
以下是修改好的代码：

package day2;


import java.util.ArrayList;

import java.util.List;


/**

* 判断101-200之间有多少个素数，并输出所有素数。

*
* @author yellowbaby

*
*/

public class Test {


        public static void main(String[] args) {


                List<Integer> list = new ArrayList<Integer>();// 存放所有的素数


                for (int num = 101; num <= 200; num++) {

                        boolean flag=isPrime(num);
                                                if(flag){
                          list.add(num);
                                                }
                }

               
                System.out.println(list);

                System.out.println("101-200之间素数的个数为:" + list.size());

        }


        /**

         * 判断是否是素数，素数的概念：指在一个大于1的自然数中，除了1和此整数自身外，不能被其他自然数整除的数

         */

        private static boolean isPrime(int num) {

                boolean flag=true;
                for (int i = 2; i < num; i++) {
                        if(num % i == 0){
                               flag=false;
                                                           break;
                        }
                }
                                return flag;
        }
}