求质数的算法，用筛法得出某数以内的质数
今天看见了一个求质数的问题，闲着无聊就想着实现了一遍，先用传统方法得到输出某数以内的所有质数：如求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：记录下自己的思路与感谢。咱也是程序猿嘛。。。。
