Wie man prüft, ob eine Zahl in Java eine Primzahl ist

Einführung

In diesem Lab werden Sie lernen, wie Sie in Java prüfen können, ob eine Zahl eine Primzahl ist. Wir beginnen damit, eine einfache Schleife zu implementieren, um die Primzahl-Eigenschaft zu bestimmen.

Als Nächstes werden wir den Prozess der Primzahlprüfung optimieren, indem wir die Quadratwurzel der Zahl nutzen. Schließlich werden wir den Code verbessern, um negative und nicht-ganzzahlige Eingaben elegant zu verarbeiten.

Implementieren Sie eine einfache Schleife zur Primzahlprüfung

In diesem Schritt werden wir ein Java-Programm schreiben, um zu prüfen, ob eine gegebene Zahl eine Primzahl ist, indem wir eine einfache Schleife verwenden. Eine Primzahl ist eine natürliche Zahl größer als 1, die keine positiven Teiler außer 1 und sich selbst hat.

Öffnen Sie die Datei HelloJava.java im WebIDE-Editor, wenn sie noch nicht geöffnet ist.
Ersetzen Sie den gesamten Inhalt der Datei durch folgenden Code:
```
import java.util.Scanner;

public class HelloJava {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("Enter a positive integer: ");
        int number = scanner.nextInt();

        if (number <= 1) {
            System.out.println(number + " is not a prime number.");
        } else {
            boolean isPrime = true;
            for (int i = 2; i < number; i++) {
                if (number % i == 0) {
                    isPrime = false;
                    break; // Exit the loop early if a divisor is found
                }
            }

            if (isPrime) {
                System.out.println(number + " is a prime number.");
            } else {
                System.out.println(number + " is not a prime number.");
            }
        }

        scanner.close();
    }
}
```
Lassen Sie uns die neuen Teile dieses Codes verstehen:
- Wir verwenden weiterhin den Scanner, um Eingaben vom Benutzer zu erhalten.
- int number = scanner.nextInt();: Diese Zeile liest einen ganzzahligen Wert, den der Benutzer eingegeben hat, und speichert ihn in der Variable number.
- if (number <= 1): Wir prüfen, ob die Zahl kleiner oder gleich 1 ist. Zahlen kleiner oder gleich 1 werden nicht als Primzahlen betrachtet.
- boolean isPrime = true;: Wir führen eine boolean-Variable namens isPrime ein und initialisieren sie mit true. Wir verwenden diese Variable, um zu verfolgen, ob die Zahl eine Primzahl ist.
- for (int i = 2; i < number; i++): Dies ist eine for-Schleife. Sie beginnt mit i gleich 2 und läuft solange, wie i kleiner als die number ist. In jeder Iteration wird i um 1 erhöht. Wir beginnen die Prüfung auf Teiler bei 2, da 1 immer ein Teiler ist und wir nach Teilern anderen als 1 und der Zahl selbst suchen.
- if (number % i == 0): Innerhalb der Schleife prüft diese Zeile, ob die number durch i ohne Rest teilbar ist (der Rest der Division ist 0). Wenn dies der Fall ist, bedeutet dies, dass wir einen Teiler anderen als 1 und die Zahl selbst gefunden haben.
- isPrime = false;: Wenn ein Teiler gefunden wird, setzen wir isPrime auf false.
- break;: Diese Anweisung beendet die for-Schleife sofort. Sobald wir einen Teiler gefunden haben, wissen wir, dass die Zahl keine Primzahl ist, also müssen wir nicht weiter prüfen.
- Schließlich prüfen wir den Wert von isPrime, um auszugeben, ob die Zahl eine Primzahl ist oder nicht.
Speichern Sie die Datei (Strg+S oder Cmd+S).
Kompilieren Sie das geänderte Programm im Terminal:
```
javac HelloJava.java
```
Wenn es keine Kompilierungsfehler gibt, wird eine Datei HelloJava.class erstellt.
Führen Sie das kompilierte Programm aus:
```
java HelloJava
```
Das Programm fordert Sie auf, eine positive Ganzzahl einzugeben. Geben Sie eine Zahl ein (z. B. 7) und drücken Sie die Eingabetaste. Das Programm teilt Ihnen mit, ob die Zahl eine Primzahl ist oder nicht. Versuchen Sie, verschiedene Zahlen wie 4, 11, 1 oder 0 einzugeben, um die Ausgabe zu sehen.
```
Enter a positive integer: 7
7 is a prime number.
```
```
Enter a positive integer: 4
4 is not a prime number.
```

Sie haben erfolgreich einen einfachen Primzahlprüfer unter Verwendung einer Schleife in Java implementiert!

Optimieren Sie die Primzahlprüfung mit der Quadratwurzel

Im vorherigen Schritt hat unsere Schleife zur Primzahlprüfung von 2 bis zur Zahl selbst iteriert. Obwohl dies funktioniert, kann es für sehr große Zahlen ineffizient sein. Wir können dies optimieren, indem wir nur nach Teilern bis zur Quadratwurzel der Zahl suchen.

Hier ist, warum diese Optimierung funktioniert: Wenn eine Zahl n einen Teiler d größer als ihre Quadratwurzel hat (d > sqrt(n)), muss es einen anderen Teiler d' geben, so dass d * d' = n. Dieser andere Teiler d' muss kleiner als die Quadratwurzel sein (d' < sqrt(n)). Daher muss, wenn eine Zahl andere Teiler als 1 und sich selbst hat, mindestens ein Teiler kleiner oder gleich ihrer Quadratwurzel sein. Wir müssen also nur nach Teilern bis zur Quadratwurzel suchen.

Öffnen Sie die Datei HelloJava.java im WebIDE-Editor.

Modifizieren Sie die for-Schleife in der main-Methode, so dass sie nur bis zur Quadratwurzel der Zahl iteriert. Ersetzen Sie den bestehenden for-Schleifenblock durch folgenden Code:

// ... (vorheriger Code) ...

if (number <= 1) {
    System.out.println(number + " is not a prime number.");
} else {
    boolean isPrime = true;
    // Optimieren Sie die Schleife, um bis zur Quadratwurzel zu prüfen
    int limit = (int) Math.sqrt(number);
    for (int i = 2; i <= limit; i++) {
        if (number % i == 0) {
            isPrime = false;
            break; // Beenden Sie die Schleife frühzeitig, wenn ein Teiler gefunden wird
        }
    }

    if (isPrime) {
        System.out.println(number + " is a prime number.");
    } else {
        System.out.println(number + " is not a prime number.");
    }
}

// ... (Rest des Codes) ...

Schauen wir uns die Änderungen an:

int limit = (int) Math.sqrt(number);: Wir berechnen die Quadratwurzel der number mit Math.sqrt(). Diese Methode gibt einen double zurück, also casten wir ihn in einen int, da unser Schleifenzähler i ein Integer ist. Wir speichern diesen Wert in einer Variablen namens limit.
for (int i = 2; i <= limit; i++): Die Schleife iteriert jetzt von 2 bis einschließlich des berechneten limit (dem ganzzahligen Teil der Quadratwurzel).

Speichern Sie die Datei (Strg+S oder Cmd+S).
Kompilieren Sie das optimierte Programm im Terminal:
```
javac HelloJava.java
```
Wiederum wird, wenn es keine Fehler gibt, eine Datei HelloJava.class generiert.
Führen Sie das kompilierte Programm aus:
```
java HelloJava
```
Geben Sie verschiedene Zahlen ein, um den optimierten Primzahlprüfer zu testen. Sie sollten die gleichen Ergebnisse wie zuvor erhalten, aber für sehr große Zahlen wird diese Version schneller sein.
```
Enter a positive integer: 29
29 is a prime number.
```
```
Enter a positive integer: 100
100 is not a prime number.
```

Sie haben Ihr Programm zur Primzahlprüfung erfolgreich optimiert, indem Sie die Anzahl der Iterationen in der Schleife reduziert haben.

Behandeln Sie negative und nicht-ganzzahlige Eingaben

In den vorherigen Schritten geht unser Programm davon aus, dass der Benutzer immer eine positive Ganzzahl eingibt. In realen Anwendungen können Benutzer jedoch negative Zahlen, Null oder sogar nicht-ganzzahligen Text eingeben. Unser aktuelles Programm behandelt diese Fälle nicht elegant. In diesem Schritt fügen wir Prüfungen hinzu, um negative und nicht-ganzzahlige Eingaben zu verarbeiten.

Öffnen Sie die Datei HelloJava.java im WebIDE-Editor.

Modifizieren Sie die main-Methode, um Prüfungen für negative Zahlen einzubeziehen und eine Schleife zu verwenden, um sicherzustellen, dass der Benutzer eine gültige positive Ganzzahl eingibt. Ersetzen Sie den bestehenden Code innerhalb der main-Methode durch Folgendes:

import java.util.Scanner;
import java.util.InputMismatchException; // Importieren Sie diese Klasse

public class HelloJava {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int number = 0;
        boolean validInput = false;

        // Schleife, bis eine gültige positive Ganzzahl eingegeben wird
        while (!validInput) {
            System.out.print("Enter a positive integer: ");
            try {
                number = scanner.nextInt();
                if (number > 0) {
                    validInput = true; // Eingabe ist gültig, Schleife beenden
                } else {
                    System.out.println("Please enter a positive integer (greater than 0).");
                }
            } catch (InputMismatchException e) {
                System.out.println("Invalid input. Please enter an integer.");
                scanner.next(); // Die ungültige Eingabe verbrauchen, um eine Endlosschleife zu vermeiden
            }
        }

        // Jetzt die Primzahlprüfung für die gültige positive Zahl durchführen
        if (number <= 1) { // Diese Prüfung ist aufgrund der Eingabeschleife technisch redundant, aber für die Klarheit gut
            System.out.println(number + " is not a prime number.");
        } else {
            boolean isPrime = true;
            int limit = (int) Math.sqrt(number);
            for (int i = 2; i <= limit; i++) {
                if (number % i == 0) {
                    isPrime = false;
                    break;
                }
            }

            if (isPrime) {
                System.out.println(number + " is a prime number.");
            } else {
                System.out.println(number + " is not a prime number.");
            }
        }

        scanner.close();
    }
}

Lassen Sie uns die neuen Ergänzungen analysieren:

import java.util.InputMismatchException;: Wir importieren diese Klasse, um Fälle zu behandeln, in denen der Benutzer etwas eingibt, das keine Ganzzahl ist.
int number = 0; boolean validInput = false;: Wir initialisieren number und eine boolean-Flagge validInput.
while (!validInput): Dies ist eine while-Schleife, die solange ausgeführt wird, wie validInput false ist.
try { ... } catch (InputMismatchException e) { ... }: Dies ist ein try-catch-Block. Der Code innerhalb des try-Blocks wird ausgeführt. Wenn eine InputMismatchException auftritt (das heißt, die Eingabe war keine Ganzzahl), wird der Code innerhalb des catch-Blocks ausgeführt.
number = scanner.nextInt();: Wir versuchen, eine Ganzzahl einzulesen.
if (number > 0): Innerhalb des try-Blocks prüfen wir, ob die eingegebene Zahl positiv ist. Wenn ja, setzen wir validInput auf true, um die Schleife zu beenden.
System.out.println("Please enter a positive integer (greater than 0).");: Wenn die Zahl nicht positiv ist, geben wir eine Fehlermeldung aus.
System.out.println("Invalid input. Please enter an integer.");: Innerhalb des catch-Blocks geben wir eine Fehlermeldung aus, wenn eine InputMismatchException auftritt.
scanner.next();: Dies ist wichtig innerhalb des catch-Blocks. Es verbraucht die ungültige Eingabe aus dem Scanner und verhindert eine Endlosschleife, in der das Programm ständig versucht, die gleiche ungültige Eingabe einzulesen.

Speichern Sie die Datei (Strg+S oder Cmd+S).
Kompilieren Sie das aktualisierte Programm:
```
javac HelloJava.java
```
Führen Sie das Programm aus:
```
java HelloJava
```
Versuchen Sie jetzt, verschiedene Arten von Eingaben zu machen:
- Geben Sie eine positive Ganzzahl ein (z. B. 13).
- Geben Sie eine negative Ganzzahl ein (z. B. -5).
- Geben Sie Null (0) ein.
- Geben Sie Text ein (z. B. "hello").
Beobachten Sie, wie das Programm diese verschiedenen Eingaben behandelt und Sie auffordert, eine gültige positive Ganzzahl einzugeben, bis Sie dies tun.
```
Enter a positive integer: -5
Please enter a positive integer (greater than 0).
Enter a positive integer: 0
Please enter a positive integer (greater than 0).
Enter a positive integer: hello
Invalid input. Please enter an integer.
Enter a positive integer: 17
17 is a prime number.
```

Sie haben Ihr Programm zur Primzahlprüfung erfolgreich robuster gemacht, indem Sie negative Zahlen und nicht-ganzzahlige Eingaben mithilfe einer Schleife und Ausnahmebehandlung verarbeitet haben.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man in Java prüft, ob eine Zahl eine Primzahl ist. Wir begannen damit, eine grundlegende Primzahlprüfung zu implementieren, indem wir eine Schleife verwendeten, die von 2 bis zur Zahl minus eins iteriert und auf Teilbarkeit prüft. Dieser erste Ansatz lieferte ein grundlegendes Verständnis der Definition von Primzahlen und ihrer algorithmischen Implementierung.

Anschließend haben wir Optimierungen untersucht, um die Effizienz der Primzahlprüfung zu verbessern. Dies beinhaltete das Verständnis, dass wir nur nach Teilern bis zur Quadratwurzel der Zahl suchen müssen, was die Anzahl der erforderlichen Iterationen für größere Eingaben erheblich reduziert. Schließlich haben wir Randfälle behandelt, indem wir negative Zahlen und nicht-ganzzahlige Eingaben berücksichtigt haben, um unsere Funktion zur Primzahlprüfung robuster und vollständig zu machen.