So überprüfen Sie, ob eine Zeichenkette in Java in eine Ganzzahl umgewandelt werden kann

Einführung

In diesem Lab lernen Sie, wie Sie prüfen können, ob eine Zeichenkette (string) in Java in eine Ganzzahl (integer) umgewandelt werden kann. Dies ist eine grundlegende Fähigkeit für die Verarbeitung von Benutzereingaben oder Daten aus externen Quellen.

Sie werden die Methode Integer.parseInt() untersuchen, um die Umwandlung zu versuchen, erfahren, wie Sie potenzielle Fehler mit NumberFormatException behandeln können, und Techniken entdecken, um eine Zeichenkette zu validieren, bevor Sie versuchen, sie zu analysieren (parsen), um so robusten und fehlerfreien Code zu gewährleisten.

Versuchen Sie, die Umwandlung mit Integer.parseInt() durchzuführen

In diesem Schritt werden wir untersuchen, wie man in Java eine String-Variable (Text) in einen int-Wert (Ganzzahl) 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 für diesen Zweck eine eingebaute Methode namens Integer.parseInt(). Schauen wir uns an, wie diese Methode funktioniert.

Stellen Sie zunächst sicher, dass Sie sich im Verzeichnis ~/project befinden. Falls erforderlich, können Sie im Terminal den Befehl cd ~/project ausführen.
Jetzt erstellen wir eine neue Java-Datei mit dem Namen StringToInt.java im Verzeichnis ~/project. Sie können dies tun, indem Sie im Dateiexplorer links mit der rechten Maustaste klicken, "Neue Datei" auswählen und StringToInt.java eingeben.
Öffnen Sie die Datei StringToInt.java im Code-Editor und fügen Sie den folgenden Code ein:
```
public class StringToInt {
    public static void main(String[] args) {
        String numberString = "123";
        int numberInt = Integer.parseInt(numberString);

        System.out.println("The string is: " + numberString);
        System.out.println("The integer is: " + numberInt);
    }
}
```
Schauen wir uns die neuen Bestandteile an:
- String numberString = "123";: Wir deklarieren eine String-Variable namens numberString und weisen ihr den Wert "123" zu. Beachten Sie, dass "123" in doppelten Anführungszeichen eingeschlossen ist, was darauf hinweist, dass es sich um eine Zeichenkette handelt.
- int numberInt = Integer.parseInt(numberString);: Dies ist der Kern dieses Schritts. Wir rufen die Methode Integer.parseInt() auf und übergeben unsere numberString als Argument. Diese Methode versucht, die Zeichenkette "123" in eine Ganzzahl umzuwandeln. Das Ergebnis wird in einer int-Variable namens numberInt gespeichert.
- System.out.println("The string is: " + numberString);: Diese Zeile gibt die ursprüngliche Zeichenkette aus.
- System.out.println("The integer is: " + numberInt);: Diese Zeile gibt die umgewandelte Ganzzahl aus.
Speichern Sie die Datei (Strg+S oder Cmd+S).
Jetzt kompilieren wir das Programm. Öffnen Sie das Terminal und führen Sie den folgenden Befehl aus:
```
javac StringToInt.java
```
Wenn die Kompilierung erfolgreich ist, sollten Sie keine Ausgabe sehen, und es wird eine Datei StringToInt.class im Verzeichnis ~/project erstellt.
Führen Sie schließlich das kompilierte Programm aus:
```
java StringToInt
```
Sie sollten die folgende Ausgabe sehen:
```
The string is: 123
The integer is: 123
```
Wie Sie sehen können, hat die Methode Integer.parseInt() die Zeichenkette "123" erfolgreich in die Ganzzahl 123 umgewandelt.

Im nächsten Schritt werden wir untersuchen, was passiert, wenn die Zeichenkette nicht in eine Ganzzahl umgewandelt werden kann.

Fangen Sie die NumberFormatException

Im vorherigen Schritt haben wir erfolgreich eine Zeichenkette, die nur Ziffern enthält, mit Integer.parseInt() in eine Ganzzahl umgewandelt. Aber was passiert, wenn die Zeichenkette Zeichen enthält, die keine Ziffern sind? Lassen Sie uns das herausfinden.

Wenn Integer.parseInt() versucht, eine Zeichenkette umzuwandeln, die keine gültige Darstellung einer Zahl ist, wirft es eine NumberFormatException. Dies ist eine Art von Fehler, der auf ein Problem mit dem Format der Zahlenzeichenkette hinweist.

Um solche Fehler gracefully (elegant) zu behandeln, können wir einen try-catch-Block verwenden. Ein try-catch-Block ermöglicht es uns, einen Codeausschnitt auszuführen, der möglicherweise einen Fehler verursacht, und wenn ein Fehler auftritt, können wir ihn "auffangen" und auf eine bestimmte Weise behandeln, um zu verhindern, dass unser Programm abstürzt.

Lassen Sie uns unser StringToInt.java-Programm ändern, um dies zu demonstrieren.

Öffnen Sie die Datei StringToInt.java im WebIDE-Editor.
Ändern Sie den Code, um einen try-catch-Block einzufügen und die Eingabezeichenkette zu ändern:
```
public class StringToInt {
    public static void main(String[] args) {
        String numberString = "abc"; // This string cannot be parsed as an integer

        try {
            int numberInt = Integer.parseInt(numberString);
            System.out.println("The string is: " + numberString);
            System.out.println("The integer is: " + numberInt);
        } catch (NumberFormatException e) {
            System.out.println("Error: Could not convert the string to an integer.");
            System.out.println("Details: " + e.getMessage());
        }
    }
}
```
Hier ist, was wir hinzugefügt haben:
- String numberString = "abc";: Wir haben die Zeichenkette in "abc" geändert, die eindeutig keine gültige Ganzzahl ist.
- try { ... }: Der Code innerhalb des try-Blocks ist der, den wir ausführen möchten. In diesem Fall ist es der Aufruf von Integer.parseInt().
- catch (NumberFormatException e) { ... }: Wenn innerhalb des try-Blocks eine NumberFormatException auftritt, wird der Code innerhalb des catch-Blocks ausgeführt.
- System.out.println("Error: Could not convert the string to an integer.");: Diese Zeile gibt eine benutzerfreundliche Fehlermeldung aus.
- System.out.println("Details: " + e.getMessage());: Diese Zeile gibt weitere Details zur Ausnahme aus, was für das Debugging hilfreich sein kann.
Speichern Sie die Datei (Strg+S oder Cmd+S).
Kompilieren Sie das geänderte Programm im Terminal:
```
javac StringToInt.java
```
Führen Sie das kompilierte Programm aus:
```
java StringToInt
```
Diesmal, da "abc" nicht als Ganzzahl geparst werden kann, wird die NumberFormatException gefangen, und Sie sollten eine Ausgabe ähnlich der folgenden sehen:
```
Error: Could not convert the string to an integer.
Details: For input string: "abc"
```
Anstatt dass das Programm abstürzt, hat der catch-Block den Fehler behandelt und eine hilfreiche Meldung ausgegeben. Dies ist eine viel bessere Benutzererfahrung!

Die Verwendung von try-catch-Blöcken ist entscheidend für das Schreiben von robusten Programmen, die unerwartete Eingaben oder Situationen verarbeiten können.

Validieren Sie die Zeichenkette vor der Umwandlung

Im vorherigen Schritt haben wir gelernt, wie man eine NumberFormatException abfängt, wenn Integer.parseInt() fehlschlägt. Während das Abfangen von Ausnahmen wichtig für die Fehlerbehandlung ist, ist es oft besser, den Fehler von vornherein zu vermeiden.

In diesem Schritt werden wir lernen, wie man eine Zeichenkette bevor man versucht, sie als Ganzzahl umzuwandeln, überprüft. Dies umfasst die Prüfung, ob die Zeichenkette nur Ziffern enthält.

Eine Möglichkeit, dies zu tun, ist es, jedes Zeichen der Zeichenkette zu durchlaufen und zu prüfen, ob es eine Ziffer ist. Ein weiterer gängiger Ansatz ist die Verwendung von regulären Ausdrücken, aber für Anfänger ist eine einfache Schleife leichter zu verstehen.

Lassen Sie uns unser StringToInt.java-Programm erneut ändern, um eine Überprüfung einzuschließen.

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

Ersetzen Sie den vorhandenen Code durch den folgenden:

public class StringToInt {

    public static void main(String[] args) {
        String numberString = "123a"; // This string contains a non-digit character

        if (isValidInteger(numberString)) {
            int numberInt = Integer.parseInt(numberString);
            System.out.println("The string is: " + numberString);
            System.out.println("The integer is: " + numberInt);
        } else {
            System.out.println("Error: The string '" + numberString + "' is not a valid integer.");
        }
    }

    // Method to check if a string is a valid integer
    public static boolean isValidInteger(String str) {
        if (str == null || str.isEmpty()) {
            return false; // An empty or null string is not a valid integer
        }
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            if (i == 0 && (c == '-' || c == '+')) {
                // Allow a leading sign (+ or -)
                continue;
            }
            if (!Character.isDigit(c)) {
                return false; // Found a non-digit character
            }
        }
        return true; // All characters are digits (or a leading sign)
    }
}

Schauen wir uns die Änderungen an:

Wir haben eine neue Methode namens isValidInteger(String str) hinzugefügt. Diese Methode nimmt eine Zeichenkette als Eingabe und gibt true zurück, wenn die Zeichenkette eine gültige Ganzzahl darstellt, und false sonst.
Innerhalb von isValidInteger überprüfen wir zunächst, ob die Zeichenkette null oder leer ist.
Wir durchlaufen dann jedes Zeichen der Zeichenkette.
Character.isDigit(c) ist eine eingebaute Java-Methode, die prüft, ob ein Zeichen eine Ziffer ist.
Wir haben eine Prüfung hinzugefügt, um ein führendes Plus- oder Minuszeichen zuzulassen.
In der main-Methode verwenden wir jetzt eine if-else-Anweisung. Wir rufen isValidInteger() auf, um die Zeichenkette bevor wir versuchen, sie umzuwandeln, zu überprüfen.
Wenn isValidInteger() true zurückgibt, gehen wir mit Integer.parseInt() vor.
Wenn es false zurückgibt, geben wir eine Fehlermeldung aus, ohne zu versuchen, die Zeichenkette umzuwandeln, und vermeiden so die NumberFormatException.

Speichern Sie die Datei (Strg+S oder Cmd+S).
Kompilieren Sie das geänderte Programm im Terminal:
```
javac StringToInt.java
```
Führen Sie das kompilierte Programm aus:
```
java StringToInt
```
Da die Zeichenkette "123a" ein Zeichen enthält, das keine Ziffer ist, wird die Methode isValidInteger false zurückgeben, und Sie sollten die folgende Ausgabe sehen:
```
Error: The string '123a' is not a valid integer.
```
Jetzt ändern wir die Zeichenkette zurück in eine gültige Ganzzahl, um den anderen Zweig der if-else-Anweisung zu sehen.
Ändern Sie die Variable numberString in der Datei StringToInt.java zurück in "456":
```
String numberString = "456";
```
Speichern Sie die Datei.
Kompilieren und führen Sie das Programm erneut aus:
```
javac StringToInt.java
java StringToInt
```
Diesmal wird isValidInteger true zurückgeben, und Sie sollten sehen:
```
The string is: 456
The integer is: 456
```

Durch die Überprüfung der Zeichenkette vor der Umwandlung können wir ungültige Eingaben gracefully (elegant) behandeln und Laufzeitfehler wie die NumberFormatException vermeiden. Dies ist eine gute Praxis für das Schreiben von robusterem und zuverlässigerem Code.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man in Java eine String-Variable in einen int-Wert mit der Methode Integer.parseInt() umwandelt. Wir haben eine Java-Datei erstellt, Code geschrieben, um die Umwandlung zu demonstrieren, und das Programm kompiliert. Diese Methode ist unerlässlich für die Verarbeitung numerischer Eingaben aus verschiedenen Quellen.