Primzaheln ermittlen

[fleckdalm]

Ich habe folgenden code geschrieben um primzahlen zu ermitteln:

public class Main {
    private int hg,zahl=0,zahl2,zahl3,zahl4,zahl5,zahl6,zahl7,zahl8,zahl9,zahl10,zahl11;
    public void berechnen(){
        hg=Integer.parseInt(JOptionPane.showInputDialog("Geben sie die höchstgrenze ein bis zu der die Primzahlen ermittelt werden sollen"));
        System.out.println("Unter dem von ihnen angegebenen wert gibt es folgende primzahlen:");
        while (zahl<hg){
            zahl++;
            zahl2=zahl*1;
            zahl3=zahl*2;
            zahl4=zahl*3;
            zahl5=zahl*4;
            zahl6=zahl*5;
            zahl7=zahl*6;
            zahl8=zahl*7;
            zahl9=zahl*8;
            zahl10=zahl*9;
            zahl11=zahl*10;
            for (int z=1;z<=hg;z++){
                if(z%zahl2!=0&&z%zahl3!=0&&z%zahl4!=0&&z%zahl5!=0&&z%zahl6!=0&&z%zahl7!=0&&z%zahl8!=0&&z%zahl9!=0&&z%zahl10!=0&&z%zahl11!=0){
                    System.out.println(""+z+"\n");
                }
            }

        }
    }

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        Main m=new Main();
        m.berechnen();
        // TODO code application logic here
    }

}

Leider funktioniert es nicht ganz bis 9 stimmt es aber dann gibt er 9 und noch viele andere Zahlen aus die keine Primzahlen sind.
ICh möchte bitte nicht auf irgendein tutorial verwiesen werden, ich würde am liebsten einfach mein programm richtigstellen/verbessern.
mfg Fleckdalm

 

[turing]

Also... wie macht man sowas: Nun, zuerst wird, wie Du schon richtig machst, festgelegt, bis zu welcher Obergrenze das ganze stattfinden soll. Dies ist bei Dir anscheinen "hg". Nun gehst du auch richtigerweise in eine Schleife, die bis hg läuft mit dem Ziel, mit jedem Schritt zu prüfen, ob die katuelle Zahl (Schritt) eine Primzahl ist oder nicht. Diese jeweils aktuelle Zahl steht in "zahl" und wird richtigerweise in jedem Schritt erhöht (man überlege Mal, ob diese Zahl wirklich bei 0 beginnen muss...).

Nun besteht in der Schleife also die Aufgabe, festzustellen, ob "zahl" eine Primzahl ist oder nicht. Im Positivfall, soll sie ausgegeben werden. Nun dazu reicht es, in einer weiteren Schleife zu prüfen, ob "zahl" durch 2,3,4... bis zahl-1 (soweit ist es eigentlich gar nicht nötig, aber egal) teilbar ist oder nicht. Wenn "zahl" auch nur durch eine andere Zahl (von 1 und zahl verschieden) teilbar ist, dann ist es wohl keine Primzahl, ansonsten ist es eine. Sollte nach Ablauf der inneren Schleife festgestellt werden, dass es eine Primzahl ist, kann sie ausgeben werden (d.h. zahl).

Eine ziemlich wörtliche, nicht sehr effizente, aber lesbare Übersetzung:

...
while (zahl<hg){
  zahl++;
  boolean isprim = true;
  for (int z=2; z<zahl; z++){
    if (zahl % z == 0) {
      isprim = false;
    }
  }     
  if (isprim) {
    System.out.println(""+zahl+"\n");  //nicht z sondern zahl
  }
}

 

[Landei]

Man kann den Code von turing auch "umdrehen": Dort wird eine Zahl nach allen möglichen Teilern durchsucht. Man kann auch die Teiler durchgehen, und alle Vielfachen "streichen". Alle nicht "gestrichenen" Zahlen sind prim. Diese Idee liegt dem Sieb des Eratosthenes zugrunde:

   public static void sieve(int max) {
       boolean[] isComposite = new boolean[max];
       for(int p = 2; p < max; p++) {
           if (! isComposite[p]) { //wenn p prim ist...
             for(int k = 2*p; k < max; k+=p) { //...alle Vielfachen...
               isComposite[k] = true; //..."durchstreichen"
             }
           }
       }

       for(int p = 2; p < max; p++) {
           if(! isComposite[p]) {
               System.out.println(p);
           }
       }
   }

Auch dieser Code kann noch stark optimiert werden (z.B. braucht man das Durchstreichen erst bei p² zu beginnen)