Imparare a eseguire il debug in Java

Question

Sono entrambi imparare ad usare il JPDA su Netbeans e risolvere il Prime Generator problema della Sfera di online Judge.

Ho letto questo tutorial su netbeans.org su lui JPDA, ma non l'ho trovato di grande aiuto.

Questo codice, che si basa su un'implementazione crivello di Eratostene è fornito da starblue qui , è in esecuzione in questo modo:

2
1 10
//here the primes between 1 and 10 should print 
3 5
//here the primes between 3 and 5 should print 




package sphere;

/**
 *
 * @author Administrator
 */
//import java.util.ArrayList;
import java.util.BitSet;
import java.lang.Math.*;
import java.util.ArrayList;

public class Main
{

  public static int ApproximateNthPrime(int nn)
{
    double n = (double)nn;
    double p;
    if (nn >= 7022)
    {
        p = n * Math.log(n) + n * (Math.log(Math.log(n)) - 0.9385);
    }
    else if (nn >= 6)
    {
        p = n * Math.log(n) + n * Math.log(Math.log(n));
    }
    else if (nn > 0)
    {
        p = new int[] { 2, 3, 5, 7, 11 }[nn - 1];
    }
    else
    {
        p = 0;
    }
    return (int)p;
}

// Find all primes up to and including the limit
public static BitSet SieveOfEratosthenes(int limit)
{
    final BitSet primes = new BitSet();
    primes.set(0,false); 
    primes.set(1,false); 
    primes.set(2,limit,true); 

    for (int i =0; i*i<limit;i++)
    {
        if (primes.get(i))
        {
            for (int j=i*1; j<limit;j+=1)
            {
                primes.clear(j);// hace que el indice j sea false (no primo)
            }

        }

    }
    return primes;
}

public static ArrayList<Integer> GeneratePrimesSieveOfEratosthenes(int n)
{
    int limit = ApproximateNthPrime(n);
    BitSet bits = SieveOfEratosthenes(limit);
    ArrayList <Integer> primes = new ArrayList<Integer>();
    for (int i = 0, found = 0; i < limit && found < n; i++)
    {
        if (bits.get(i))
        {
            primes.add(i);
            found++;
        }
    }
    return primes;
}





  public static void main (String[] args) throws java.lang.Exception
  {
     java.io.BufferedReader r = new java.io.BufferedReader (new java.io.InputStreamReader (System.in));
     String s;

     s= r.readLine();

     int test_cases = Integer.parseInt(s);


     int case_counter =0;

     while (case_counter<test_cases) {

        // System.out.println(s);
         s = r.readLine();

         String [] splitted = s.split(" ");

         int lower_bound = Integer.parseInt(splitted[0]);
         int upper_bound = Integer.parseInt(splitted[1]);



        ArrayList <Integer> primesList=  GeneratePrimesSieveOfEratosthenes(upper_bound);



         for (int i =0; i<primesList.size();i++){
            if (primesList.get(i)<=lower_bound)System.out.println(primesList.get(i));
         }


         case_counter++;

         System.out.println(" "); // space that separates test cases

     }
  }
}

So che l'ArrayList primesList non è sempre inizializzato e io sono sospettoso di questo pezzo di codice, causo onestamente, non capisco è:

if (primes.get(i))
        {
            for (int j=i*1; j<limit;j+=1)
            {
                primes.clear(j);
            }

        }

Mi venne in mente di utilizzare un punto di interruzione condizionale qui con la condizione di:

primes.get(j)==false

Ma non sono sicuro se sono in grado di ottenere informazioni significative in questo modo. Queste sono le schermate che sto ricevendo:

alt text http://img525.imageshack.us/img525/6238/breakpoints .jpg

alt text http://img98.imageshack.us/img98/5262/watchesz .jpg

Non so come ottenere informazioni utili da questo.

Le mie domande sono:

a) voglio guardare i numeri primi bitset come il suo passare attraverso questo ciclo.

Come faccio a farlo?

b) Che cosa è esattamente sbagliato con questo codice? Come hai fatto a individuare utilizzando il debugger?

, parlare del processo step-by-step.

Answer 1

Quindi, ho estratto il seguente metodo:

    private static void printPrimes(int lower_bound, int upper_bound) {
    ArrayList<Integer> primesList = GeneratePrimesSieveOfEratosthenes(upper_bound);

    for (int i = 0; i < primesList.size(); i++) {
        if (primesList.get(i) <= lower_bound)
            System.out.println(primesList.get(i));
    }
}

e cambiato il metodo main() di chiamare solo che con un paio di argomenti arbitrari (10 e 100), perché non ho voglia di pasticciare con la console e il debugger, allo stesso tempo. Ho poi (sto usando Eclipse) ha messo i punti di interruzione ordinarie le linee di inizio e fine ApproximateNthPrime(), SieveOfEratosthenes() e GeneratePrimesSieveOfEratosthenes() per assicurarsi che essi sono stati chiamati. (A proposito, la convenzione Java, a differenza di C #, è per i nomi di metodo per iniziare con una lettera minuscola.)

Tutto ciò che era senza preoccuparsi di capire il codice. :) Tuttavia, dopo la prima prova, era abbastanza chiaro che il problema è che il prodotto da BitSet false è sempre vuota (o meglio, sempre interamente <=>). Non ho usato il debugger NetBeans, ma ho il sospetto la "variabili locali" scheda è tuo amico qui.

Non ho intenzione di fare il vostro lavoro per voi. :) Ma l'idea del crivello di Eratostene è quello di saltare i numeri primi ed eliminare solo i non-numeri primi. Esaminare il metodo <=> e chiedetevi:? Quando intende saltare un numero di