Apprendre à déboguer en Java

Question

Je suis à la fois apprendre à utiliser le JPDA sur Netbeans et résoudre le premier générateur problème de juge en ligne de Sphère.

J'ai lu ce tutoriel sur netbeans.org au sujet qu'il jpda, mais n'a pas trouvé d'une grande aide.

Ce code, qui est basé sur une mise en œuvre Crible d'Ératosthène fourni par starblue , est en cours d'exécution comme ceci:

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

     }
  }
}

Je sais que le ArrayList primesList ne reçoit pas initialisé et je me méfie de ce morceau de code, parce que honnêtement, je ne comprends pas bien:

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

        }

Il me vint d'utiliser un point d'arrêt conditionnel ici avec la condition de:

primes.get(j)==false

Mais je ne suis pas sûr si je suis en mesure d'obtenir des informations significatives de cette façon. Ce sont les écrans que je reçois:

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

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

Je ne sais pas comment obtenir des informations utiles sur ce sujet.

Mes questions sont les suivantes:

a) Je veux regarder les nombres premiers BITSET comme passer par cette boucle.

Comment puis-je faire?

b) Quelle est exactement le problème avec ce code? Comment avez-vous place à l'aide du débogueur?

S'il vous plaît, mentionner le processus étape par étape.

Answer 1

Alors, je tirai la méthode suivante:

    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));
    }
}

et changé la méthode pour appeler juste main() que, avec quelques arguments arbitraires (10 et 100), parce que je ne voulais pas déranger avec la console et le débogueur en même temps. Je me suis alors (j'utilise Eclipse) a mis des points d'arrêt ordinaires aux lignes de début et de fin de ApproximateNthPrime(), et SieveOfEratosthenes() pour se assurer GeneratePrimesSieveOfEratosthenes() qu'ils étaient appelés. (Soit dit en passant, convention Java, contrairement à C #, est pour les noms de méthode de commencer par une lettre minuscule.)

Tout ce qui était sans prendre la peine de comprendre le code. :) Cependant, après la première exécution à travers, il est assez clair que le problème est que le produit par BitSet est toujours vide false (ou plutôt, toujours entièrement <=>). Je ne l'ai pas utilisé le débogueur NetBeans, mais je soupçonne que l'onglet « Variables locales » est votre ami ici.

Je ne vais pas faire vos devoirs pour vous. :) Mais l'idée du Sieve d'Eratosthène est de sauter les nombres premiers et éliminer uniquement les non-nombres premiers. Examinez votre méthode et demandez-vous <=>: quand sera-t sauter un numéro