求质数的方法

一、利用BitSet（筛法）  
import java.util.*;
public class BitSetTest{
   public static void main(String[] args){
      BitSet sieve=new BitSet(1024);
      int size=sieve.size();
      for(int i=2;i< size;i++)
           sieve.set(i);
      int finalBit=(int)Math.sqrt(sieve.size());
      
      for(int i=2;i< finalBit;i++)
         if(sieve.get(i))
           for(int j=2*i;j< size;j+=i)
               sieve.clear(j);
      
      int counter=0;
      for(int i=1;i< size;i++){
          if(sieve.get(i)){
             System.out.printf("%5d",i);
             if(++counter%15==0)
                System.out.println();
          }
       }
    }
}
C:/java>java BitSetTest
2   3   5   7   11  13  17  19  23  29  31  37  41  43  47
53  59  61  67  71  73  79  83  89  97  101 103 107 109 113
127 131 137 139 149 151 157 163 167 173 179 181 191 193 197
199 211 223 227 229 233 239 241 251 257 263 269 271 277 281
283 293 307 311 313 317 331 337 347 349 353 359 367 373 379
383 389 397 401 409 419 421 431 433 439 443 449 457 461 463
467 479 487 491 499 503 509 521 523 541 547 557 563 569 571
577 587 593 599 601 607 613 617 619 631 641 643 647 653 659
661 673 677 683 691 701 709 719 727 733 739 743 751 757 761
769 773 787 797 809 811 821 823 827 829 839 853 857 859 863
877 881 883 887 907 911 919 929 937 941 947 953 967 971 977
983 991 997 1009 1013 1019 1021
C:/java>
    
                       
二、  一个计算质数的Java程序 （作者：cindyruiwei）
     这个Java程序用来计算质数，基本原理就是判断整除，用一个ArrayList记录已知的质数，一开始放入3，5，7，11，13，17，19，23，29，然后从31开始对奇数进行for(int n=31; ;n+=2)循环，对每个待判断的n，用已知的质数依次判断是否能整除，如果得到一个新的质数，就把它放到ArrayList中。 

     特殊之处在于，我把它实现了序列化，每次启动时可以恢复到上次的状态，还可以把所有质数导出到文件，每4byte是一个质数，从小到大排列。我用这个程序计算了100,000个质数，算到的最大的质数是1299709,下面是源代码：


import java.io.*;
import java.util.*;


public class PrimeNumber implements Serializable
{
    private ArrayList list;
    private int nStart;
   public PrimeNumber()
    {
        list=new ArrayList(9);
        list.add(new Integer(3));
        list.add(new Integer(5));
        list.add(new Integer(7));
        list.add(new Integer(11));
        list.add(new Integer(13));
        list.add(new Integer(17));
        list.add(new Integer(19));
        list.add(new Integer(23));
        list.add(new Integer(29));
        nStart=31;
    }




    public void calculate(int number)
    {
        System.out.print("Start calculating prime numbers... ");
        if (number<=0)
            return;
        list.ensureCapacity(number);
        int nGot=0;
        boolean bPrime;
        int n;
        for(int nTest=nStart; ; nTest+=2)
        {
            bPrime=true;
            for(int i=0; i< list.size(); i++)
            {
                n=((Integer)(list.get(i))).intValue();
                if (nTest % n == 0)
                // not a prime number:
                {
                    bPrime=false;
                    break;
                }
            }
            if (bPrime) // found a prime number
            {
                list.add(new Integer(nTest));
                nGot++;
                System.out.print("/nFound "+nTest+", "+(number-nGot)+" left.");
                if (nGot==number) // ok, finish calculation.
                {
                    nStart=nTest+2;
                    System.out.println("/ndone./n");
                    return;
                }
            }
        }
    }
    public static boolean store(PrimeNumber obj)
    {
        ObjectOutputStream objOut = null;
        try
        {
            objOut=new ObjectOutputStream(new FileOutputStream("prime.obj"));
            objOut.writeObject(obj);
            return true;
        }
        catch(Exception e) {}
        finally {
            if(objOut!=null) {
                try { objOut.close(); } catch(Exception e) {}
            }
        }
        return false;
    }


    public static PrimeNumber load()
    {
        try
        {
            ObjectInput objIn=new ObjectInputStream(new FileInputStream("prime.obj"));
            PrimeNumber pn=(PrimeNumber)objIn.readObject();
            objIn.close();
            return pn;
        }
        catch(Exception e)
        {
        }
        return null;
    }
    public void display()
    {
        System.out.print("/nThere are " + (list.size()+1) + " prime numbers./n2/t");
        for(int i=0; i< list.size(); i++)
        {
            System.out.print(list.get(i).toString());
            System.out.print("/t");
        }
        System.out.println("/n");
    }
    public void displayLast()
    {
        int nStart=list.size()-20;
        System.out.println("/nThe last 20 prime numbers:");
        if(nStart<0)
            System.out.print("2/t");
        for(int i=nStart; i< list.size(); i++)
        {
            if (i>=0)
                System.out.print(list.get(i).toString()+"/t");
        }
        System.out.println("/n");
    }
   public void storeAsFile()
    {
        DataOutputStream dos = null;
        try {
            dos = new DataOutputStream(new BufferedOutputStream(
                  new FileOutputStream("prime.data")));
            dos.writeInt(2);
            for(int i=0; i< list.size(); i++) {
                dos.writeInt(((Integer)list.get(i)).intValue());
            }
            System.out.println("Prime numbers has been saved./n");
        }
        catch(Exception e) {
            System.out.println("There is an error occured. Saving failed./n");
        }
        finally {
            if(dos!=null) {
                try { dos.close(); } catch(Exception e) {}
            }
        }
    }

    public static void main(String[] args)
    {
        // first try to read from disk:
        System.out.print("Reading from file... ");
        PrimeNumber pn=PrimeNumber.load();
        if (pn==null)
        {
            System.out.println("failed./nCreate a new calculator... done.");
            pn=new PrimeNumber();
        }
        else
            System.out.println("done.");
        int sel;
        do
        {
            System.out.println("==============================================================");
            sel=pn.getCommand();
            switch(sel)
            {
                case 1:
                    pn.calculate(10);
                    break;
                case 2:
                    pn.calculate(100);
                    break;
                case 3:
                    pn.calculate(1000);
                    break;
                case 4:
                    pn.calculate(10000);
                    break;
                case 5:
                    pn.display();
                    break;
                case 6:
                    pn.displayLast();
                    break;
                case 7:
                    pn.storeAsFile();
                    break;
                case 8:
                    break;
                default:
                    System.out.println("Invalid command.");
            }
        }while(sel!=8);
        System.out.print("/nWriting to file... ");
        System.out.println(PrimeNumber.store(pn)==true?"done.":"failed.");
    }
    public int getCommand()
    {
        System.out.println("  Total "+(list.size()+1)+" prime numbers calculated. Select:");
        System.out.println("    1. Calculate next 10 prime numbers.");
        System.out.println("    2. Calculate next 100 prime numbers.");
        System.out.println("    3. Calculate next 1000 prime numbers.");
        System.out.println("    4. Calculate next 10000 prime numbers.");
        System.out.println("    5. Display all prime numbers.");
        System.out.println("    6. Display the last 20 numbers.");
        System.out.println("    7. Save all prime numbers as a file.");
        System.out.println("    8. Save all prime numbers and quit.");
        System.out.print  ("  Your selection: ");
        int sel=0;
        try
        {
            InputStreamReader isr=new InputStreamReader(System.in);
            sel=isr.read()-48;
        }
        catch(IOException e){}
        return sel;
    }
}


下面是一次运行的部分结果：


==============================================================
Total 110 prime numbers calculated. Select:
1. Calculate next 10 prime numbers.
2. Calculate next 100 prime numbers.
3. Calculate next 1000 prime numbers.
4. Calculate next 10000 prime numbers.
5. Display all prime numbers.
6. Display the last 20 numbers.
7. Save all prime numbers as a file.
8. Save all prime numbers and quit.
Your selection: 5

There are 110 prime numbers.
2     3     5     7    11   13   17   19   23  29
31   37   41   43   47   53   59   61   67  71
73   79   83   89   97  101 103 107 109 113
127 131 137 139 149 151 157 163 167 173
179 181 191 193 197 199 211 223 227 229
233 239 241 251 257 263 269 271 277 281
283 293 307 311 313 317 331 337 347 349
353 359 367 373 379 383 389 397 401 409
419 421 431 433 439 443 449 457 461 463
467 479 487 491 499 503 509 521 523 541
547 557 563 569 571 577 587 593 599 601


==============================================================
Total 110 prime numbers calculated. Select:
1. Calculate next 10 prime numbers.
2. Calculate next 100 prime numbers.
3. Calculate next 1000 prime numbers.
4. Calculate next 10000 prime numbers.
5. Display all prime numbers.
6. Display the last 20 numbers.
7. Save all prime numbers as a file.
8. Save all prime numbers and quit.
Your selection:


三、第三个程序 

作者：wolfigo

/*个人认为比较经典的一段求任意范围质数的小程序*/
/*布尔数组isPrime[]，其中的元素为true时，表示为质数*/
/*
    Demo Test Data: 打印1-10之间的数是否是质数
           测试结果:  false, true, true, false, true, false, true, false, false, false
                    (  1      2      3     4      5     6     7     8      9       10  )
    其它范围的测试结果以此类推。
*/
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Sieve
{
    private static boolean[] sieve(int range)
    {
        boolean[] isPrime = new boolean[range + 1];
        for (int i = 1; i < isPrime.length; i++)
        {
            isPrime[i] = true;
        }

        isPrime[1] = false;

        int n = (int) Math.ceil(Math.sqrt(range));
        for (int j = 1; j <= n; j++)
        {
            if (isPrime[j])
            {
                for (int k = 2 * j; k <= range; k += j)
                {
                    isPrime[k] = false;
                }
            }
        }

        return isPrime;
    }

    private static int findLargest(boolean[] isPrime)
    {
        int largest = isPrime.length - 1;
        for (; !isPrime[largest]; largest--);
        
        return largest;
    }

    public static void main(String[] args)
    {
        BufferedReader input = new BufferedReader(new InputStreamReader(
                System.in));
        int param = 0;

        try
        {
            param = Integer.parseInt(input.readLine());
        }
        catch (NumberFormatException e)
        {
            System.out.println("Invalid Argument.");
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }

        boolean[] isPrime = sieve(param);
        for (int i = 1; i < isPrime.length; i++)
        {
            System.out.print(isPrime[i] + ", ");
        }
        
        System.out.println();
        System.out.println(findLargest(isPrime));
    }
}