Is this the best way to test a prime number?

Question

Ok so I think I finally got my program to work. I tested It with very big 8 digit prime numbers if that means anything. here are 2 Questions about my program"
-Is this a way of finding prime numbers? (does the program fulfill its purpose?)
and Second is there a smarter way of doing it?
Here is the program:
//This program tests if a number is a prime number
import java.util.Scanner;
public class Main
public static void main ( String args [ ] )
Scanner input = new Scanner( System.in );
int number;
int bob;
System.out.print(" Enter the number you wish to test:\n");
number = input.nextInt();
if (number == 1)
System.out.print(" 1 is divisible only by 1, therefore it is not prime or composite\n");
if (number == 2)
System.out.print(" It's Prime\n ");
for ( int test = 2 ; test < number ; test++ )
bob = number % test;
if ( bob == 0)
System.out.print("It's Composite\n");
return;
System.out.println("It's Prime");
}

Answer 1

I got interested in this ...
//1. PrimeTester_BruteForce: found 3001134 primes <= 50000000 in 410500 milliseconds
//2. PrimeTester_SieveOfEratosthenes: found 3001134 primes <= 50000000 in 4422 milliseconds
//3. PrimeTester_SieveOfAtkin: found 3001134 primes <= 50000000 in 24843 milliseconds
... so Wkipedia's SieveOfAtkin algorithm apparently requires some serious optimization before it outruns the Greeks... see http://cr.yp.to/primegen.html for an optimized C implementation (which I can't follow).
PrimeTester_BruteForce.java//find all prime numbers upto the given maximum.
//Using the brute force method
//http://www.newton.dep.anl.gov/newton/askasci/1995/math/MATH039.HTM
//PrimeTester_BruteForce: found 3001134 primes <= 50000000 in 410500 milliseconds
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
public class PrimeTester_BruteForce {
     public static void main(String[] argv) throws IOException {
          long start = System.currentTimeMillis();
          PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("PrimeTester_BruteForce.txt")));
          int limit = 50000000;
          int count = 0;
nextn:     for (int n=2; n<=limit; n++) {
               int top = (int)Math.sqrt(n);
               for(int i=2; i<=top; i++) {
                    if(n%i==0) {
                         continue nextn;
               out.print(n);
               out.print(" ");
               if(++count%20==0) out.println();
          long took = System.currentTimeMillis()-start;
          out.println();
          out.println("PrimeTester_BruteForce: found "+count+" primes <= "+limit+" in "+took+" milliseconds");
          out.close();
PrimeTester_SieveOfEratosthenes.java/******************************************************************************
//find all prime numbers upto the given maximum.
//http://en.wikipedia.org/wiki/Sieve_of_Eratosthenes
limit = 1000000;       // arbitrary search limit
// pressume all are prime
for (i=2; i<=limit; i++) is_prime[i] = true;
// eliminate multiples of each prime, starting with its square
for (n=2; n<=sqrt(limit); n++) {
   if (is_prime[n]) {
      for (i=n^2; i<=limit; i+=n) is_prime[i] = false;
// print the results
for (n=2; n=<limit; n++) {
  if (is_prime[n]) print(n);
//PrimeTester_SieveOfEratosthenes: found 164185 primes <= 1000000 in 125 milliseconds
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
public class PrimeTester_SieveOfEratosthenes {
     public static void main(String[] argv) throws IOException {
          long start = System.currentTimeMillis();
          PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("PrimeTester_SieveOfEratosthenes.txt")));
          int limit = 50000000;
          int n, i;
          boolean[] is_prime = new boolean[limit+1];
          // pressume all are prime
          is_prime[2] = true;
          for (i=2; i<=limit; i++) {
               is_prime[i] = true;
          // eliminate multiples of each prime, starting with its square
          for (n=1; n<=Math.sqrt(limit); n++) {
               if (is_prime[n]) {
                    for (i=n*2; i<=limit; i+=n) {
                         is_prime[i] = false;
          // print the results
          int count = 0;
          for (n=2; n<=limit; n++) {
               if (is_prime[n]) {
                    out.print(n);
                    out.print(" ");
                    if(++count%20==0) out.println();
          long took = System.currentTimeMillis()-start;
          out.println();
          out.println("PrimeTester_SieveOfEratosthenes: found "+count+" primes <= "+limit+" in "+took+" milliseconds");
          out.close();
PrimeTester_SieveOfAtkin.java/******************************************************************************
//find all prime numbers upto the given maximum.
//http://en.wikipedia.org/wiki/Sieve_of_Atkin
limit = 1000000; // Arbitrary search limit
array is_prime[5:limit] initial false; // Sieve array.
biginteger x,y,n,k; // Must be able to hold 5*limit: 4x^2 + y^2!
// put in candidate primes: integers which have an odd number of representations
// by certain quadratic forms.
for x:=1:sqrt(limit) do
for y:=1:sqrt(limit) do
   n:=4x^2 + y^2; if n<=limit and n%12 = 1 or 5 then is_prime[n]:=not is_prime[n];
   n:=3x^2 + y^2; if n<=limit and n%12 = 7 then is_prime[n]:=not is_prime[n];
   n:=3x^2 - y^2; if n<=limit and x>y and n%12 = 11 then is_prime[n]:=not is_prime[n];
next y;
next x;
// eliminate composites by sieving
// if n is prime, omit all multiples of its square; this is sufficient because
// composites which managed to get on the list cannot be square-free
for n:=5:sqrt(limit) do
  if is_prime[n] then for k:=n^2:limit:n^2 do is_prime[k]:=false; next k;
next n;
// Present the results.
print 2, 3; for n:= 5:limit do if is_prime[n] then print n; next n;
//PrimeTester_SieveOfAtkin: found 441 primes <= 1000000 in 203 milliseconds
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
public class PrimeTester_SieveOfAtkin {
     public static void main(String[] argv) throws IOException {
          long start = System.currentTimeMillis();
          PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("PrimeTester_SieveOfAtkin.txt")));
          int limit = 50000000;
          int sqrt = (int)Math.sqrt(limit);
          boolean[] is_prime = new boolean[limit+1]; // Sieve array.
          int x, y, n, k; // Must be able to hold 5*limit: 4x^2 + y^2!
          // put in candidate primes: integers which have an odd number of representations by certain quadratic forms.
          for (x=1; x<=sqrt; x++) {
               for (y=1; y<=sqrt; y++) {
                    //n=(4*(x^2)) + y^2; if (n<=limit && n%12 in(1,5)) is_prime[n] = !is_prime[n];
                    int xSq = (int)Math.pow(x,2);
                    int ySq = (int)Math.pow(y,2);
                    n = 4*xSq + ySq;
                    if (n<=limit && (n%12==1||n%12==5)) {
                         is_prime[n]= !is_prime[n];
                         //debug("A: x="+x+", y="+y+", is_prime["+n+"]="+is_prime[n]);
                    //n=((3*(x^2)) + y^2; if (n<=limit && n%12==7) is_prime[n] = !is_prime[n];
                    n = 3*xSq + ySq;
                    if (n<=limit && n%12==7) {
                         is_prime[n]= !is_prime[n];
                         //debug("B: x="+x+", y="+y+", is_prime["+n+"]="+is_prime[n]);
                         //debug("   if (n<=limit:"+limit+" && n%12:"+(n%12)+"==7");
                         //debug("   (3*(x^2)):"+xSq+" + (y^2):"+ySq);
                    //n=((3*(x^2)) - y^2; if (n<=limit && x>y && n%12==11) is_prime[n]= !is_prime[n];
                    n = 3*xSq - ySq;
                    if (n<=limit && x>y && (n%12==11)) {
                         is_prime[n]= !is_prime[n];
                         //debug("C: x="+x+", y="+y+", is_prime["+n+"]="+is_prime[n]);
               }//next y
          }//next x
          // eliminate composites by sieving
          // if n is prime, omit all multiples of its square; this is sufficient because
          // composites which managed to get on the list cannot be square-free
          // for (n:=5:sqrt(limit)) {
          //   if (is_prime[n]) for (k:=n^2:limit:n^2) is_prime[k]:=false;
          for (n=5; n<=sqrt; n++) {
               if (is_prime[n]) {
                    int nSq = (int)Math.pow(n,2);
                    for(k=nSq; k<=limit; k+=nSq) {
                         is_prime[k]=false;
                         //debug("D: n="+n+" is_prime["+k+"]="+is_prime[k]);
          // Present the results.
          int count = 2;
          out.print("2 3 ");
          for(n=5; n<=limit; n++) {
               if(is_prime[n]) {
                    out.format("%d ", n);
                    if(++count%20==0) out.println();
          long took = System.currentTimeMillis()-start;
          out.println();
          out.println("PrimeTester_SieveOfAtkin: found "+count+" primes <= "+limit+" in "+took+" milliseconds");
          out.close();
     //private static void debug(String msg) {
     //     System.out.println(msg);
}