求质数的算法，用筛法得出某数以内的质数

今天看见了一个求质数的问题，闲着无聊就想着实现了一遍，先用传统方法得到输出某数以内的所有质数：如求1000以内的所有质数，

和输入100，即得到大于自然数1的100个质数。哈哈，也算复习了下数学知识啦。

现在贴下几种实现方法的代码:

1、输入某数，即得到大于自然数1的多少个质数：

 1 /**
 2      * 质数集合
 3 */
 4     static Set<Integer> primeNumSet = new HashSet<Integer>();
 5     
 6     
 7     /**
 8      * 检查是否合数
 9      * @param number
10      * @return
11 */
12     public static boolean checkIsComposite(int number){
13         Iterator<Integer> num = primeNumSet.iterator();
14         while (num.hasNext()) {
15             if(number%num.next() == 0){
16                 return true;
17             }
18         }
19         return false;
20     }
21     
22     /**
23      * 得到numberCount个大于自然数1的质数
24      * @param numberCount
25 */
26     public static void getPrimeNumByCount(int numberCount){
27         for (int i = 2; true; i++) {
28             //检查是否是合数    
29             if (checkIsComposite(i)) {
30                 continue;
31             }
32             
33             primeNumSet.add(i);
34             if (primeNumSet.size()>=numberCount) {
35                 return;
36             }
37         }
38     }
39     
40 
41     
42     /**
43      * 打印
44 */
45     public static void print(){
46         //排序    
47         List<Integer> tempSort =new ArrayList<Integer>();
48         tempSort.addAll(primeNumSet);
49         
50         //输出
51         Collections.sort(tempSort);
52         Iterator<Integer> prime=tempSort.iterator();
53         
54         int i=1;
55         while (prime.hasNext()) {
56             System.out.print(prime.next()+"\t");
57             
58             //换行
59             if (i%10==0) {
60                 System.out.print("\n");
61             }
62             i++;
63         }
64     }
65     
66     public static void main(String[] args) {
67         double beginTime = System.currentTimeMillis();
68         
69         try {
70             
71             getPrimeNumByCount(10000);
72             
73 
74         } catch (Exception e) {
75             e.printStackTrace();
76         }
77         
78         double endTime = System.currentTimeMillis();
79         
80         print();
81         
82         double numCount = 0;
83         
84         numCount = primeNumSet.size();
85         
86         System.out.println("\n输出完毕！总计"+numCount+"个质数,耗时："+String.valueOf((endTime-beginTime)/1000)+"秒");
87         
88         
89     }

2、得到并输出某数以内的所有质数：

 1     /**
 2      * 质数集合
 3 */
 4     private static Set<Integer> primeNumSet = new HashSet<Integer>();
 5 
 6     /**
 7      * 检查是否合数
 8      * @param number
 9      * @return
10 */
11     private static boolean checkIsComposite(int number){
12         Iterator<Integer> num = primeNumSet.iterator();
13         while (num.hasNext()) {
14             if(number%num.next() == 0){
15                 return true;
16             }
17         }
18         return false;
19     }
20         
21     /**
22      * 得到maxNum以内的质数
23      * @param maxNum
24 */
25     public static void getPrimeNumByMaxNum(int maxNum){
26         
27         double beginTime = System.currentTimeMillis();
28         
29         
30         for (int i = 2; i<=maxNum; i++) {
31             //检查是否是合数    
32             if (checkIsComposite(i)) {
33                 continue;
34             }
35             
36             primeNumSet.add(i);
37             
38         }
39         
40         double endTime = System.currentTimeMillis();
41         
42         print();
43         
44         double numCount = 0;
45         
46         numCount = primeNumSet.size();
47         
48         System.out.println("\n输出完毕！总计"+numCount+"个质数,耗时："+String.valueOf((endTime-beginTime)/1000)+"秒");
49     }    
50         
51 
52     
53     /**
54      * 打印
55 */
56     private static void print(){
57         //排序    
58         List<Integer> tempSort =new ArrayList<Integer>();
59         tempSort.addAll(primeNumSet);
60         
61         //输出
62         Collections.sort(tempSort);
63         Iterator<Integer> prime=tempSort.iterator();
64         
65         int i=1;
66         while (prime.hasNext()) {
67             System.out.print(prime.next()+"\t");
68             
69             //换行
70             if (i%10==0) {
71                 System.out.print("\n");
72             }
73             i++;
74         }
75     }
76 
77     public static void main(String[] args) {
78         getPrimeNumByMaxNum(1000);
79     }

3、用筛法算法得到某数以内的所有质数（最佳）：

 1 /**
 2      * 质数集合
 3 */
 4     static Set<Integer> primeNumSet = new HashSet<Integer>();
 5     
 6     /**
 7      * 合数集合
 8 */
 9     static Set<Integer> compositeNumSet = new HashSet<Integer>();
10         
11         
12     /**
13      * 得到maxNum以内的质数(筛法)
14      * @param maxNum
15 */
16     public static void getPrimeNumByMaxNumOfSieve(int maxNum){
17         
18         for (int i = 2; i<=maxNum; i++) {
19             
20             if (!compositeNumSet.contains(i)) {
21                 primeNumSet.add(i);
22                 filterMultiple(i, maxNum);
23             }
24         }        
25     }
26     
27     
28     /**
29      * 筛除maxNum以内baseNum倍数，添加到合数集合
30      * @param maxNum
31 */
32     public static void filterMultiple(int baseNum,int maxNum){
33         for (int i = 2; true; i++) {
34             if(baseNum * i <= maxNum){
35                 
36                 compositeNumSet.add(baseNum * i);
37                 
38             }else{
39                 break;
40             }
41         }
42         
43     }
44     
45     /**
46      * 打印
47 */
48     public static void print(){
49         //排序    
50         List<Integer> tempSort =new ArrayList<Integer>();
51         tempSort.addAll(primeNumSet);
52         
53         //输出
54         Collections.sort(tempSort);
55         Iterator<Integer> prime=tempSort.iterator();
56         
57         int i=1;
58         while (prime.hasNext()) {
59             System.out.print(prime.next()+"\t");
60             
61             //换行
62             if (i%10==0) {
63                 System.out.print("\n");
64             }
65             i++;
66         }
67     }
68     
69     public static void main(String[] args) {
70         double beginTime = System.currentTimeMillis();
71         
72         try {
73             
74             getPrimeNumByMaxNumOfSieve(150000);
75 
76         } catch (Exception e) {
77             e.printStackTrace();
78         }
79         
80         double endTime = System.currentTimeMillis();
81         
82         print();
83         
84         double numCount = 0;
85         
86         numCount = primeNumSet.size();
87         
88         System.out.println("\n输出完毕！总计"+numCount+"个质数,耗时："+String.valueOf((endTime-beginTime)/1000)+"秒");
89         
90         
91     }

暂时就研究出这几种。。

对比了下三种方法，用第三种（筛法）效率明显比前两种快好几倍，而且随着输入参数的增大，效率与之成正比。

但是这三种算法都有一个bug，即输入参数不能过大，已经测试的是在1000000左右是极限，超过这个数字会报 内存溢出 异常，

这个还有待改进，后面有尝试用分页的思路存储质数和合数，可以实现效果，但是效率大打折扣。

应该还有更好的方法，尝试中.....

ps：记录下自己的思路与感谢。咱也是程序猿嘛。。。。