Wie man prüft, ob eine Zeichenkette in Java in eine Fließkommazahl umgewandelt werden kann

Einführung

In diesem Lab lernen Sie, wie Sie feststellen können, ob eine gegebene Zeichenkette (String) in Java erfolgreich in eine Gleitkommazahl (double) mit doppelter Genauigkeit umgewandelt werden kann. Wir werden den Prozess untersuchen, bei dem versucht wird, eine Zeichenkette mit Double.parseDouble() zu analysieren, verstehen, wie potenzielle NumberFormatException-Fehler behandelt werden können, die auftreten können, wenn die Zeichenkette keine gültige numerische Darstellung ist, und Methoden besprechen, um zu überprüfen, ob eine Zeichenkette einem gültigen Dezimalformat entspricht. Am Ende dieses Labs verfügen Sie über das Wissen, um Zeichenketten in Ihren Java-Anwendungen sicher und effektiv in Gleitkommazahlen umzuwandeln.

Versuch des Parsings mit Double.parseDouble()

In diesem Schritt lernen wir, wie man in Java eine Zeichenkette, die eine Zahl darstellt, in einen numerischen Datentyp umwandelt. Dies ist eine häufige Aufgabe, wenn man Eingaben von Benutzern erhält oder Daten aus einer Datei liest, da Eingaben zunächst oft als Text (Zeichenketten) gelesen werden.

Java bietet mehrere Möglichkeiten, diese Umwandlung durchzuführen. Eine der gängigsten Methoden, um eine Zeichenkette in eine Gleitkommazahl (double) mit doppelter Genauigkeit umzuwandeln, ist die Double.parseDouble()-Methode.

Erstellen wir ein einfaches Java-Programm, um dies zu demonstrieren.

Ö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 decimal number: ");
        String userInput = scanner.nextLine();

        // Attempt to parse the input string into a double
        double number = Double.parseDouble(userInput);

        System.out.println("You entered: " + number);

        scanner.close();
    }
}
```
Schauen wir uns die neuen Teile dieses Codes an:
- System.out.print("Enter a decimal number: ");: Diese Zeile fordert den Benutzer auf, eine Dezimalzahl einzugeben.
- String userInput = scanner.nextLine();: Diese Zeile liest die Eingabe des Benutzers als Zeichenkette und speichert sie in der Variable userInput.
- double number = Double.parseDouble(userInput);: Dies ist der Kern dieses Schritts. Double.parseDouble() nimmt die userInput-Zeichenkette und versucht, sie in einen double-Wert umzuwandeln. Wenn die Zeichenkette erfolgreich als Dezimalzahl interpretiert werden kann, wird der resultierende double-Wert in der Variable number gespeichert.
- System.out.println("You entered: " + number);: Diese Zeile gibt den geparsten double-Wert an den Benutzer zurück.
Speichern Sie die Datei (Strg+S oder Cmd+S).
Kompilieren Sie nun das geänderte Programm. Öffnen Sie das Terminal unten im WebIDE und stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden. Führen Sie dann aus:
```
javac HelloJava.java
```
Wenn die Kompilierung erfolgreich ist, sehen Sie keine Ausgabe.
Führen Sie schließlich das Programm aus:
```
java HelloJava
```
Das Programm fordert Sie auf, eine Dezimalzahl einzugeben. Geben Sie eine gültige Dezimalzahl wie 123.45 ein und drücken Sie die Eingabetaste.
```
Enter a decimal number: 123.45
You entered: 123.45
```
Das Programm sollte Ihre Eingabe erfolgreich parsen und die Zahl an Sie zurückgeben.

In diesem Schritt haben Sie erfolgreich Double.parseDouble() verwendet, um eine gültige Zeichenkette, die eine Dezimalzahl darstellt, in einen double-Wert umzuwandeln. Was passiert jedoch, wenn der Benutzer etwas eingibt, das keine gültige Zahl ist? Dies werden wir im nächsten Schritt untersuchen.

NumberFormatException behandeln

Im vorherigen Schritt haben wir gesehen, wie Double.parseDouble() funktioniert, wenn die Eingabezeichenkette eine gültige Dezimalzahl ist. Aber was passiert, wenn der Benutzer Text eingibt, der nicht in eine Zahl umgewandelt werden kann? Versuchen wir es.

Stellen Sie sicher, dass Sie sich im Terminal im Verzeichnis ~/project befinden.
Führen Sie das Programm erneut aus:
```
java HelloJava
```
Wenn Sie aufgefordert werden, eine Dezimalzahl einzugeben, geben Sie etwas ein, das eindeutig keine Zahl ist, wie hello oder abc.
```
Enter a decimal number: hello
```
Drücken Sie die Eingabetaste. Wahrscheinlich sehen Sie im Terminal eine Menge roten Text. Dies ist eine Fehlermeldung, genauer gesagt eine NumberFormatException.
```
Exception in thread "main" java.lang.NumberFormatException: For input string: "hello"
    at java.base/jdk.internal.math.FloatingDecimal.readJavaFormatString(FloatingDecimal.java:2050)
    at java.base/jdk.internal.math.FloatingDecimal.parseDouble(FloatingDecimal.java:110)
    at java.base/java.lang.Double.parseDouble(Double.java:651)
    at HelloJava.main(HelloJava.java:10)
```
Diese NumberFormatException tritt auf, weil die Zeichenkette "hello" nicht in einen gültigen double-Wert geparst werden kann. Wenn eine solche Ausnahme auftritt und nicht behandelt wird, stürzt das Programm ab und hört auf, auszuführen.

In realen Anwendungen möchten Sie nicht, dass Ihr Programm abstürzt, nur weil ein Benutzer ungültige Eingaben macht. Sie benötigen eine Möglichkeit, solche Fehler gracefully (elegant) zu behandeln. In Java verwenden wir try-catch-Blöcke, um Ausnahmen zu behandeln.

Ein try-catch-Block funktioniert wie folgt:
- Der Code, der eine Ausnahme verursachen könnte, wird in den try-Block platziert.
- Wenn innerhalb des try-Blocks eine Ausnahme auftritt, wird der Code innerhalb des catch-Blocks ausgeführt.
- Wenn keine Ausnahme auftritt, wird der catch-Block übersprungen.

Lassen Sie uns unser Programm ändern, um einen try-catch-Block zu verwenden, um die NumberFormatException zu behandeln.

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

Ändern Sie den Code, um den Aufruf von Double.parseDouble() in einen try-catch-Block zu packen:

import java.util.Scanner;

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

        System.out.print("Enter a decimal number: ");
        String userInput = scanner.nextLine();

        try {
            // Attempt to parse the input string into a double
            double number = Double.parseDouble(userInput);
            System.out.println("You entered: " + number);
        } catch (NumberFormatException e) {
            // This code runs if a NumberFormatException occurs
            System.out.println("Invalid input. Please enter a valid decimal number.");
        }

        scanner.close();
    }
}

In diesem aktualisierten Code:

Die Zeile Double.parseDouble(userInput); befindet sich innerhalb des try-Blocks.
Der catch (NumberFormatException e)-Block gibt an, dass wenn im try-Block eine NumberFormatException auftritt, der Code innerhalb des catch-Blocks ausgeführt werden soll.
Innerhalb des catch-Blocks geben wir eine benutzerfreundliche Fehlermeldung aus, anstatt das Programm abstürzen zu lassen.

Speichern Sie die Datei (Strg+S oder Cmd+S).
Kompilieren Sie das geänderte Programm:
```
javac HelloJava.java
```
Führen Sie das Programm erneut aus:
```
java HelloJava
```
Wenn Sie aufgefordert werden, geben Sie erneut ungültige Eingaben wie hello ein.
```
Enter a decimal number: hello
Invalid input. Please enter a valid decimal number.
```
Diesmal hat das Programm die NumberFormatException gefangen und die Meldung aus dem catch-Block ausgegeben, anstatt abzustürzen. Dies ist eine viel bessere Benutzererfahrung!

Sie haben nun gelernt, wie Sie try-catch-Blöcke verwenden, um Ausnahmen wie NumberFormatException zu behandeln, wodurch Ihre Programme robuster und benutzerfreundlicher werden.

Auf gültiges Dezimalformat prüfen

Im vorherigen Schritt haben wir die NumberFormatException erfolgreich mit einem try-catch-Block behandelt. Dies verhindert, dass unser Programm abstürzt, wenn die Eingabe keine gültige Zahl ist. Allerdings versucht der aktuelle Ansatz immer noch, die Zeichenkette zu parsen und fängt den Fehler erst nach dem fehlgeschlagenen Parsing ab.

Ein proaktiverer Ansatz besteht darin, zu prüfen, ob die Eingabezeichenkette ein gültiges Dezimalformat hat, bevor man versucht, sie zu parsen. Dies kann mit regulären Ausdrücken oder anderen Validierungstechniken erfolgen. In diesem Lab werden wir eine einfache Prüfung innerhalb einer Schleife verwenden, um den Benutzer wiederholt zur Eingabe aufzufordern, bis eine gültige Dezimalzahl angegeben wird.

Dieser Ansatz kombiniert den try-catch-Block mit einer Schleife, um sicherzustellen, dass wir eine gültige Eingabe erhalten.

Öffnen Sie die Datei HelloJava.java im WebIDE-Editor.
Ändern Sie den Code, um eine Schleife einzufügen, die so lange fortgesetzt wird, bis eine gültige Eingabe erhalten wird:
```
import java.util.Scanner;

public class HelloJava {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        double number = 0.0; // Initialize with a default value
        boolean validInput = false; // Flag to track valid input

        while (!validInput) {
            System.out.print("Enter a decimal number: ");
            String userInput = scanner.nextLine();

            try {
                // Attempt to parse the input string into a double
                number = Double.parseDouble(userInput);
                validInput = true; // Set flag to true if parsing is successful
            } catch (NumberFormatException e) {
                // This code runs if a NumberFormatException occurs
                System.out.println("Invalid input. Please enter a valid decimal number.");
            }
        }

        System.out.println("You entered a valid number: " + number);

        scanner.close();
    }
}
```
Schauen wir uns die Änderungen an:
- double number = 0.0;: Wir initialisieren die Variable number außerhalb der Schleife.
- boolean validInput = false;: Wir führen eine boolesche Variable validInput ein, um die Schleife zu steuern. Sie ist zunächst false.
- while (!validInput): Dies erstellt eine while-Schleife, die so lange fortgesetzt wird, wie validInput false ist.
- Innerhalb des try-Blocks setzen wir validInput auf true, wenn Double.parseDouble() erfolgreich ist. Dies führt dazu, dass die Schleife nach der aktuellen Iteration beendet wird.
- Wenn eine NumberFormatException auftritt, wird der catch-Block ausgeführt, validInput bleibt false und die Schleife wird fortgesetzt, wobei der Benutzer erneut zur Eingabe aufgefordert wird.
- Nachdem die Schleife beendet ist (d.h. validInput ist true), geben wir eine Meldung aus, die bestätigt, dass eine gültige Eingabe erhalten wurde.
Speichern Sie die Datei (Strg+S oder Cmd+S).
Kompilieren Sie das geänderte Programm:
```
javac HelloJava.java
```
Führen Sie das Programm aus:
```
java HelloJava
```
Versuchen Sie nun zunächst ungültige Eingaben einzugeben und geben Sie dann eine gültige Dezimalzahl ein.
```
Enter a decimal number: abc
Invalid input. Please enter a valid decimal number.
Enter a decimal number: 1.2.3
Invalid input. Please enter a valid decimal number.
Enter a decimal number: 789.01
You entered a valid number: 789.01
```
Das Programm wird so lange nach Eingaben fragen, bis Sie eine Zeichenkette angeben, die Double.parseDouble() erfolgreich umwandeln kann.

Sie haben nun eine einfache Eingabevalidierungsschleife implementiert, die sicherstellt, dass Ihr Programm eine gültige Dezimalzahl vom Benutzer erhält, bevor es fortfährt. Dies ist ein grundlegendes Muster für die Verarbeitung von Benutzereingaben in vielen Anwendungen.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man prüft, ob eine Zeichenkette in Java in eine Fließkommazahl (double) umgewandelt werden kann. Wir haben begonnen, indem wir versucht haben, eine Zeichenkette mit der Methode Double.parseDouble() in eine Fließkommazahl zu parsen. Diese Methode ist eine gängige Möglichkeit, die Zeichenkettenrepräsentationen von Zahlen in numerische Typen umzuwandeln und besonders nützlich, wenn man Benutzereingaben oder aus Dateien gelesene Daten verarbeitet. Wir haben ein einfaches Java-Programm implementiert, das den Benutzer zur Eingabe auffordert, diese als Zeichenkette liest und dann Double.parseDouble() verwendet, um sie in eine Fließkommazahl umzuwandeln. Dadurch wurde der grundlegende Prozess der Umwandlung von Zeichenketten in Fließkommazahlen demonstriert.