Wie man prüft, ob eine Zeichenkette in Java numerisch ist

Einführung

In diesem Lab werden Sie verschiedene Methoden lernen, um zu überprüfen, ob eine gegebene Zeichenkette in Java einen numerischen Wert darstellt. Wir beginnen damit, zu untersuchen, wie man versucht, eine Zeichenkette in eine Ganzzahl umzuwandeln und potenzielle Fehler zu behandeln, wenn die Zeichenkette keine gültige Zahl ist.

Danach werden Sie entdecken, wie Sie die Stärke von regulären Ausdrücken nutzen können, um eine flexiblere und robustere Prüfung auf numerische Werte durchzuführen. Abschließend erweitern wir unser Verständnis, um Zeichenketten zu verarbeiten, die negative Zahlen und Dezimalwerte darstellen, um sicherzustellen, dass unsere Prüfungen auf numerische Werte umfassend sind.

Versuch, eine Zeichenkette in eine Ganzzahl umzuwandeln

In diesem Schritt werden wir untersuchen, wie man in Java eine Zeichenkette (Text) in eine Ganzzahl (eine ganze Zahl) umwandelt. Dies ist eine häufige Aufgabe in der Programmierung, insbesondere wenn Sie numerische Eingaben von einem Benutzer erhalten oder Zahlen aus einer Datei lesen müssen.

Java bietet eine eingebaute Möglichkeit, dies mit der Methode Integer.parseInt() zu tun. Was passiert jedoch, wenn die Zeichenkette tatsächlich keine gültige Zahl darstellt? Lassen Sie uns dies herausfinden, indem wir ein einfaches Java-Programm schreiben.

Öffnen Sie die Datei HelloJava.java im WebIDE-Editor, wenn sie noch nicht geöffnet ist.
Ersetzen Sie den gesamten Inhalt der Datei durch den folgenden Code:
```
public class HelloJava {
    public static void main(String[] args) {
        String numberString = "123";
        int number = Integer.parseInt(numberString);
        System.out.println("Successfully parsed: " + number);

        String invalidString = "abc";
        try {
            int invalidNumber = Integer.parseInt(invalidString);
            System.out.println("This line will not be reached.");
        } catch (NumberFormatException e) {
            System.out.println("Error: Could not parse '" + invalidString + "' to an integer.");
            System.out.println("Exception details: " + e.getMessage());
        }
    }
}
```
Schauen wir uns die neuen Teile dieses Codes an:
- String numberString = "123";: Wir erstellen eine Zeichenkettenvariable numberString und weisen ihr den Wert "123" zu.
- int number = Integer.parseInt(numberString);: Dies ist der Kern der Konvertierung. Integer.parseInt() versucht, die Zeichenkette "123" in eine Ganzzahl umzuwandeln. Da "123" eine gültige Ganzzahlrepräsentation ist, wird dies erfolgreich sein, und der Ganzzahlwert 123 wird in der Variable number gespeichert.
- String invalidString = "abc";: Wir erstellen eine weitere Zeichenkettenvariable invalidString und weisen ihr den Wert "abc" zu. Diese Zeichenkette stellt keine gültige Ganzzahl dar.
- try { ... } catch (NumberFormatException e) { ... }: Dies ist ein try-catch-Block, der in Java zur Fehlerbehandlung (Ausnahmen) verwendet wird.
  - Der Code innerhalb des try-Blocks ist der Ort, an dem wir die Operation platzieren, die einen Fehler verursachen könnte. In diesem Fall ist es Integer.parseInt(invalidString).
  - Wenn Integer.parseInt("abc") fehlschlägt, weil "abc" keine gültige Zahl ist, wird es eine NumberFormatException "werfen".
  - Der catch (NumberFormatException e)-Block "fängt" diese spezifische Art von Ausnahme auf. Der Code innerhalb des catch-Blocks wird dann ausgeführt.
- System.out.println("Error: Could not parse '" + invalidString + "' to an integer.");: Diese Zeile wird ausgegeben, wenn die NumberFormatException auftritt.
- System.out.println("Exception details: " + e.getMessage());: Dies gibt eine genauere Fehlermeldung aus, die von dem Ausnahmeobjekt e bereitgestellt wird.
Speichern Sie die Datei (Strg+S oder Cmd+S).
Kompilieren Sie das Programm im Terminal:
```
javac HelloJava.java
```
Wenn keine Fehler auftreten, sehen Sie keine Ausgabe.
Führen Sie das kompilierte Programm aus:
```
java HelloJava
```
Sie sollten eine Ausgabe ähnlich der folgenden sehen:
```
Successfully parsed: 123
Error: Could not parse 'abc' to an integer.
Exception details: For input string: "abc"
```
Diese Ausgabe zeigt, dass der erste Parsing-Versuch erfolgreich war, aber der zweite Versuch mit der ungültigen Zeichenkette "abc" zu einer NumberFormatException führte, und unser catch-Block hat diesen Fehler elegant behandelt, indem er eine Fehlermeldung ausgegeben hat.

Dies zeigt die Wichtigkeit der Behandlung potenzieller Fehler beim Konvertieren von Zeichenketten in Zahlen, da nicht alle Zeichenketten erfolgreich geparst werden können. Die Verwendung von try-catch-Blöcken ist eine Standardmethode, um solche Situationen in Java zu bewältigen.

Verwenden Sie reguläre Ausdrücke für die numerische Prüfung

Im vorherigen Schritt haben wir gesehen, dass Integer.parseInt() eine Ausnahme wirft, wenn die Zeichenkette keine gültige Ganzzahl ist. Während try-catch nützlich ist, um den Fehler zu behandeln, wenn er auftritt, möchten Sie manchmal überprüfen, ob eine Zeichenkette in eine Zahl umgewandelt werden kann, bevor Sie den Versuch der Konvertierung unternehmen. Hier kommen reguläre Ausdrücke (Regex) ins Spiel.

Reguläre Ausdrücke sind leistungsstarke Muster, die verwendet werden, um Zeichenkombinationen in Zeichenketten zu finden. Wir können ein einfaches Regex-Muster verwenden, um zu überprüfen, ob eine Zeichenkette nur aus Ziffern besteht.

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

Ersetzen Sie den gesamten Inhalt der Datei durch den folgenden Code:

public class HelloJava {
    public static void main(String[] args) {
        String numberString = "123";
        String invalidString = "abc";
        String mixedString = "123a";

        System.out.println("Checking string: \"" + numberString + "\"");
        if (numberString.matches("\\d+")) {
            System.out.println("  Matches the pattern (contains only digits).");
            int number = Integer.parseInt(numberString);
            System.out.println("  Parsed integer: " + number);
        } else {
            System.out.println("  Does not match the pattern.");
        }

        System.out.println("\nChecking string: \"" + invalidString + "\"");
        if (invalidString.matches("\\d+")) {
            System.out.println("  Matches the pattern (contains only digits).");
        } else {
            System.out.println("  Does not match the pattern.");
        }

        System.out.println("\nChecking string: \"" + mixedString + "\"");
        if (mixedString.matches("\\d+")) {
            System.out.println("  Matches the pattern (contains only digits).");
        } else {
            System.out.println("  Does not match the pattern.");
        }
    }
}

Lassen Sie uns die neuen Teile analysieren:

numberString.matches("\\d+"): Dies ist der Kern der Überprüfung. Die Methode matches() ist für alle Zeichenkettenobjekte in Java verfügbar. Sie überprüft, ob die gesamte Zeichenkette dem angegebenen regulären Ausdrucksmuster entspricht.
"\\d+": Dies ist das reguläre Ausdrucksmuster.
- \\d: Dies entspricht jeder Ziffer (0 bis 9). Wir verwenden \\, weil \ ein Sonderzeichen in Java-Zeichenketten ist, daher müssen wir es escapen.
- +: Dies ist ein Quantifizierer, der bedeutet "ein oder mehrere" des vorhergehenden Elements. Somit bedeutet \\d+ "ein oder mehrere Ziffern".
Die if-Anweisung überprüft das Ergebnis von matches(). Wenn es true zurückgibt, bedeutet dies, dass die Zeichenkette ausschließlich aus einem oder mehreren Ziffern besteht. Wenn es false zurückgibt, bedeutet dies, dass die Zeichenkette andere Zeichen als Ziffern enthält oder leer ist.

Speichern Sie die Datei (Strg+S oder Cmd+S).
Kompilieren Sie das Programm im Terminal:
```
javac HelloJava.java
```
Wenn die Kompilierung erfolgreich ist, sollten Sie keine Ausgabe sehen.
Führen Sie das kompilierte Programm aus:
```
java HelloJava
```
Sie sollten eine Ausgabe ähnlich der folgenden sehen:
```
Checking string: "123"
  Matches the pattern (contains only digits).
  Parsed integer: 123

Checking string: "abc"
  Does not match the pattern.

Checking string: "123a"
  Does not match the pattern.
```
Wie Sie sehen können, hat die Überprüfung matches("\\d+") korrekt erkannt, dass "123" nur aus Ziffern besteht, während "abc" und "123a" nicht dem Muster entsprachen. Dieser Ansatz ermöglicht es Ihnen, das Format der Zeichenkette zu validieren, bevor Sie versuchen, sie zu parsen, und vermeidet so möglicherweise in einigen Fällen die NumberFormatException.

Behandlung von negativen und Dezimalzahlen

In den vorherigen Schritten haben wir uns auf das Parsen positiver ganzer Zahlen konzentriert. Allerdings können Zahlen auch negativ sein oder Dezimalstellen haben. In diesem Schritt lernen wir, wie man diese Fälle beim Konvertieren von Zeichenketten in Zahlen in Java behandelt.

Java bietet verschiedene Methoden zum Parsen unterschiedlicher Zahlentypen:

Integer.parseInt(): Für ganze Zahlen (Integers).
Double.parseDouble(): Für Zahlen mit Dezimalstellen (Fließkommazahlen).

Lassen Sie uns unser Programm so ändern, dass es negative Ganzzahlen und Dezimalzahlen verarbeiten kann.

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

Ersetzen Sie den gesamten Inhalt der Datei durch den folgenden Code:

public class HelloJava {
    public static void main(String[] args) {
        String positiveIntString = "456";
        String negativeIntString = "-789";
        String decimalString = "123.45";
        String invalidString = "not a number";

        // Handling Integers (positive and negative)
        System.out.println("Attempting to parse integers:");
        try {
            int positiveInt = Integer.parseInt(positiveIntString);
            System.out.println("  Parsed '" + positiveIntString + "' as integer: " + positiveInt);
        } catch (NumberFormatException e) {
            System.out.println("  Could not parse '" + positiveIntString + "' as integer.");
        }

        try {
            int negativeInt = Integer.parseInt(negativeIntString);
            System.out.println("  Parsed '" + negativeIntString + "' as integer: " + negativeInt);
        } catch (NumberFormatException e) {
            System.out.println("  Could not parse '" + negativeIntString + "' as integer.");
        }

        try {
            int decimalAsInt = Integer.parseInt(decimalString);
            System.out.println("  Parsed '" + decimalString + "' as integer: " + decimalAsInt);
        } catch (NumberFormatException e) {
            System.out.println("  Could not parse '" + decimalString + "' as integer.");
        }

        // Handling Decimal Numbers
        System.out.println("\nAttempting to parse decimal numbers:");
        try {
            double decimal = Double.parseDouble(decimalString);
            System.out.println("  Parsed '" + decimalString + "' as double: " + decimal);
        } catch (NumberFormatException e) {
            System.out.println("  Could not parse '" + decimalString + "' as double.");
        }

        try {
            double intAsDouble = Double.parseDouble(positiveIntString);
            System.out.println("  Parsed '" + positiveIntString + "' as double: " + intAsDouble);
        } catch (NumberFormatException e) {
            System.out.println("  Could not parse '" + positiveIntString + "' as double.");
        }

         try {
            double invalidAsDouble = Double.parseDouble(invalidString);
            System.out.println("  Parsed '" + invalidString + "' as double: " + invalidAsDouble);
        } catch (NumberFormatException e) {
            System.out.println("  Could not parse '" + invalidString + "' as double.");
        }
    }
}

Hier ist, was passiert:

Wir haben jetzt Zeichenketten, die eine positive Ganzzahl, eine negative Ganzzahl, eine Dezimalzahl und eine ungültige Zeichenkette repräsentieren.
Wir verwenden Integer.parseInt() innerhalb von try-catch-Blöcken, um zu versuchen, die Zeichenketten als Ganzzahlen zu parsen. Beachten Sie, dass Integer.parseInt() das Minuszeichen (-) verarbeiten kann. Allerdings wird es eine NumberFormatException werfen, wenn die Zeichenkette eine Dezimalstelle oder Nicht-Ziffernzeichen enthält.
Wir verwenden Double.parseDouble() innerhalb von try-catch-Blöcken, um zu versuchen, die Zeichenketten als Dezimalzahlen (Doubles) zu parsen. Double.parseDouble() kann sowohl Ganzzahlen als auch Zahlen mit Dezimalstellen verarbeiten. Es wird eine NumberFormatException für Zeichenketten werfen, die keine gültigen Darstellungen einer Double-Zahl sind.

Speichern Sie die Datei (Strg+S oder Cmd+S).
Kompilieren Sie das Programm im Terminal:
```
javac HelloJava.java
```
Wenn die Kompilierung erfolgreich ist, sollten Sie keine Ausgabe sehen.
Führen Sie das kompilierte Programm aus:
```
java HelloJava
```
Sie sollten eine Ausgabe ähnlich der folgenden sehen:
```
Attempting to parse integers:
  Parsed '456' as integer: 456
  Parsed '-789' as integer: -789
  Could not parse '123.45' as integer.

Attempting to parse decimal numbers:
  Parsed '123.45' as double: 123.45
  Parsed '456' as double: 456.0
  Could not parse 'not a number' as double.
```
Diese Ausgabe zeigt, dass Integer.parseInt() die positive und negative Ganzzahl korrekt geparst hat, aber bei der Dezimalzeichenkette fehlgeschlagen ist. Double.parseDouble() hat sowohl die Dezimalzeichenkette als auch die Ganzzahlzeichenkette erfolgreich geparst (diese als Double repräsentiert, z.B. 456.0), aber bei der ungültigen Zeichenkette fehlgeschlagen.

Dieser Schritt zeigt, wie man die geeigneten Parsing-Methoden für verschiedene Zahlentypen verwendet und unterstreicht die Wichtigkeit der Verwendung von try-catch-Blöcken, um potenzielle NumberFormatException-Fehler zu behandeln, wenn die Eingabezeichenkette möglicherweise nicht im erwarteten Format vorliegt.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man in Java prüft, ob eine Zeichenkette numerisch ist. Zunächst haben wir die Verwendung von Integer.parseInt() untersucht, um zu versuchen, eine Zeichenkette in eine Ganzzahl umzuwandeln. Dabei haben wir verstanden, dass diese Methode eine NumberFormatException wirft, wenn die Zeichenkette keine gültige Darstellung einer Ganzzahl ist. Wir haben gesehen, wie man diese Ausnahme mit einem try-catch-Block behandeln kann, um nicht-numerische Zeichenketten elegant zu verwalten.

Auf dieser Grundlage haben wir dann gelernt, wie man reguläre Ausdrücke als flexibleren Ansatz verwendet, um auf numerische Zeichenketten zu prüfen, die verschiedene Formate verarbeiten können. Schließlich haben wir unser Verständnis erweitert, um auch die Behandlung von negativen und Dezimalzahlen zu umfassen, wenn man feststellt, ob eine Zeichenkette einen numerischen Wert darstellt.