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

Einführung

In diesem Lab erfahren Sie, wie Sie in Java prüfen können, ob eine Gleitkommazahl "Not a Number" (NaN) ist. Wir werden die Methode Double.isNaN() untersuchen, verstehen, wie NaN-Werte durch Gleitkommaoperationen generiert werden, und betrachten, wie nicht-Gleitkommaeingaben im Zusammenhang mit NaN-Prüfungen behandelt werden können. Am Ende dieses Labs können Sie NaN-Werte in Ihren Java-Programmen zuverlässig erkennen und verwalten.

Verwenden Sie Double.isNaN() für die Prüfung

In diesem Schritt erfahren Sie, wie Sie in Java mithilfe der Methode Double.isNaN() prüfen können, ob eine Gleitkommazahl "Not a Number" (NaN) ist.

Gleitkommazahlen in Computern können manchmal einen speziellen Wert namens NaN ergeben. Dies geschieht, wenn das Ergebnis einer Berechnung undefiniert ist oder nicht als Standardzahl dargestellt werden kann. Beispielsweise kann die Division von Null durch Null oder die Wurzel aus einer negativen Zahl zu NaN führen.

Es ist wichtig, in Ihren Programmen NaN-Werte erkennen zu können, da sie sich anders verhalten als normale Zahlen. Beispielsweise ergibt der Vergleich eines NaN-Werts mit einer anderen Zahl (auch einem anderen NaN) mit Standardvergleichsoperatoren (==, <, >) immer false.

Java bietet eine spezielle Methode zur Prüfung auf NaN: Double.isNaN(). Diese Methode nimmt einen double-Wert als Eingabe und gibt true zurück, wenn der Wert NaN ist, und false sonst.

Erstellen wir ein einfaches Java-Programm, um zu zeigen, wie man Double.isNaN() verwendet.

Öffnen Sie die Datei HelloJava.java im WebIDE-Editor.
Ersetzen Sie den vorhandenen Code durch folgenden:
```
public class CheckNaN {
    public static void main(String[] args) {
        double result1 = 0.0 / 0.0; // This will result in NaN
        double result2 = 10.0 / 2.0; // This is a regular number

        System.out.println("Is result1 NaN? " + Double.isNaN(result1));
        System.out.println("Is result2 NaN? " + Double.isNaN(result2));
    }
}
```
In diesem Code:
- Wir deklarieren zwei double-Variablen, result1 und result2.
- result1 wird das Ergebnis von 0.0 / 0.0 zugewiesen, was eine unbestimmte Form ist und NaN erzeugen wird.
- result2 wird das Ergebnis von 10.0 / 2.0 zugewiesen, was eine Standardzahl (5.0) ist.
- Wir verwenden dann Double.isNaN(), um zu prüfen, ob result1 und result2 NaN sind, und geben die Ergebnisse aus.
Speichern Sie die Datei (Strg+S oder Cmd+S).
Jetzt müssen wir dieses neue Programm kompilieren. Da wir den Klassennamen in CheckNaN geändert haben, müssen wir CheckNaN.java kompilieren. Öffnen Sie das Terminal und führen Sie aus:
```
javac CheckNaN.java
```
Wenn die Kompilierung erfolgreich ist, sollten Sie keine Ausgabe sehen.
Führen Sie schließlich das kompilierte Programm aus:
```
java CheckNaN
```
Sie sollten eine Ausgabe ähnlich der folgenden sehen:
```
Is result1 NaN? true
Is result2 NaN? false
```
Diese Ausgabe bestätigt, dass Double.isNaN() result1 korrekt als NaN und result2 als normale Zahl identifiziert hat.

Die Verwendung von Double.isNaN() ist die richtige und zuverlässige Methode, um in Java auf NaN-Werte zu prüfen. Das Verlassen auf einen direkten Vergleich (== Double.NaN) wird nicht empfohlen, da, wie bereits erwähnt, NaN == NaN zu false auswertet.

Testen mit Gleitkommaoperationen

In diesem Schritt werden wir weitere Beispiele von Gleitkommaoperationen untersuchen, die zu NaN führen können, und das Verwenden von Double.isNaN() zur Prüfung auf diese Werte üben. Das Verständnis, welche Operationen NaN erzeugen, ist entscheidend für das Schreiben von robustem Java-Code, der potenzielle Fehler elegant behandelt.

Neben der Division von Null durch Null können auch andere Operationen, die Unendlichkeit oder ungültige mathematische Funktionen betreffen, NaN erzeugen. Java hat spezielle Darstellungen für positive und negative Unendlichkeit (Double.POSITIVE_INFINITY und Double.NEGATIVE_INFINITY).

Ändern wir unser CheckNaN.java-Programm, um einige dieser Fälle zu testen.

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

Ersetzen Sie den vorhandenen Code durch folgenden:

public class CheckNaN {
    public static void main(String[] args) {
        double result1 = 0.0 / 0.0; // NaN
        double result2 = Math.sqrt(-1.0); // NaN (square root of a negative number)
        double result3 = Double.POSITIVE_INFINITY - Double.POSITIVE_INFINITY; // NaN
        double result4 = 10.0 / 0.0; // Positive Infinity
        double result5 = -10.0 / 0.0; // Negative Infinity
        double result6 = 5.0; // Regular number

        System.out.println("Is result1 NaN? " + Double.isNaN(result1));
        System.out.println("Is result2 NaN? " + Double.isNaN(result2));
        System.out.println("Is result3 NaN? " + Double.isNaN(result3));
        System.out.println("Is result4 NaN? " + Double.isNaN(result4));
        System.out.println("Is result5 NaN? " + Double.isNaN(result5));
        System.out.println("Is result6 NaN? " + Double.isNaN(result6));
    }
}

In diesem aktualisierten Code:

result1 ist immer noch 0.0 / 0.0.
result2 verwendet Math.sqrt(-1.0), was für reelle Zahlen mathematisch undefiniert ist und zu NaN führt.
result3 subtrahiert positive Unendlichkeit von positiver Unendlichkeit, eine weitere unbestimmte Form, die zu NaN führt.
result4 und result5 demonstrieren die Division durch Null, die zu positiver oder negativer Unendlichkeit führt, nicht zu NaN.
result6 ist eine einfache Zahl zum Vergleich.

Speichern Sie die Datei (Strg+S oder Cmd+S).
Kompilieren Sie das geänderte Programm im Terminal:
```
javac CheckNaN.java
```
Wiederum bedeutet die fehlende Ausgabe, dass die Kompilierung erfolgreich war.
Führen Sie das Programm aus:
```
java CheckNaN
```
Sie sollten eine Ausgabe ähnlich der folgenden sehen:
```
Is result1 NaN? true
Is result2 NaN? true
Is result3 NaN? true
Is result4 NaN? false
Is result5 NaN? false
Is result6 NaN? false
```
Diese Ausgabe zeigt, dass Double.isNaN() die drei Operationen, die zu NaN führen, korrekt identifiziert hat, und die Unendlichkeitswerte sowie die normale Zahl korrekt als nicht-NaN identifiziert hat.

Durch das Testen mit diesen verschiedenen Gleitkommaoperationen gewinnen Sie ein besseres Verständnis dafür, wann NaN auftreten kann und wie Sie Double.isNaN() verwenden können, um diese Fälle in Ihren Programmen zu behandeln.

Behandlung von Nicht-Gleitkomma-Eingaben

In den vorherigen Schritten haben wir uns darauf konzentriert, wie Gleitkommaoperationen zu NaN führen können. Manchmal erhalten Sie jedoch möglicherweise Eingaben, die überhaupt keine gültigen Zahlen sind, wie z. B. Text. Wenn Sie versuchen, solche Eingaben in eine Gleitkommazahl umzuwandeln, kann dies ebenfalls zu Problemen führen.

Während Double.isNaN() speziell für die Prüfung der Ergebnisse von Gleitkomma-Berechnungen dient, ist es auch wichtig, Fälle zu behandeln, in denen die ursprüngliche Eingabe nicht als Zahl interpretiert werden kann. Java bietet Methoden zum Parsen von Zeichenketten in Zahlen, und diese Methoden können Ausnahmen auslösen, wenn die Eingabe ungültig ist.

Erstellen wir ein neues Programm, das versucht, die Benutzereingabe als double zu parsen und dann prüft, ob der geparste Wert NaN ist.

Erstellen Sie eine neue Datei im Verzeichnis ~/project mit dem Namen ParseAndCheck.java. Sie können dies tun, indem Sie mit der rechten Maustaste im Dateiexplorer klicken und "Neue Datei" auswählen, und dann ParseAndCheck.java eingeben.
Öffnen Sie die Datei ParseAndCheck.java im WebIDE-Editor und fügen Sie folgenden Code hinzu:
```
import java.util.Scanner;

public class ParseAndCheck {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter a floating-point number or an expression (e.g., 0.0/0.0): ");
        String input = scanner.nextLine();

        try {
            double value = Double.parseDouble(input);

            if (Double.isNaN(value)) {
                System.out.println("The input resulted in NaN.");
            } else {
                System.out.println("The input is a valid number: " + value);
            }
        } catch (NumberFormatException e) {
            System.out.println("Invalid input: Could not parse as a number.");
        } finally {
            scanner.close();
        }
    }
}
```
Lassen Sie uns diesen Code analysieren:
- Wir importieren die Scanner-Klasse, um Benutzereingaben zu lesen.
- Wir fordern den Benutzer auf, eine Zeichenkette einzugeben.
- Wir verwenden einen try-catch-Block, um potenzielle Fehler während des Parsens zu behandeln.
- Double.parseDouble(input) versucht, die Eingabezeichenkette in einen double-Wert umzuwandeln. Wenn die Zeichenkette kein gültiges Zahlenformat ist (z. B. "hello"), wird eine NumberFormatException ausgelöst.
- Innerhalb des try-Blocks überprüfen wir, wenn das Parsen erfolgreich war, mit Double.isNaN(value), ob der resultierende double-Wert NaN ist.
- Der catch-Block fängt die NumberFormatException ab und gibt eine Fehlermeldung aus, wenn die Eingabe nicht als Zahl geparst werden konnte.
- Der finally-Block stellt sicher, dass der Scanner geschlossen wird.
Speichern Sie die Datei (Strg+S oder Cmd+S).
Kompilieren Sie das Programm im Terminal:
```
javac ParseAndCheck.java
```

Führen Sie das Programm aus:

java ParseAndCheck

Das Programm wird Sie zur Eingabe auffordern. Versuchen Sie, verschiedene Werte einzugeben:

Geben Sie 5.5 ein:

Enter a floating-point number or an expression (e.g., 0.0/0.0): 5.5
The input is a valid number: 5.5

Geben Sie 0.0/0.0 ein:
```
Enter a floating-point number or an expression (e.g., 0.0/0.0): 0.0/0.0
Invalid input: Could not parse as a number.
```
(Hinweis: parseDouble kann mathematische Ausdrücke nicht direkt auswerten. Es parst nur Zeichenkettenrepräsentationen von Zahlen.)

Geben Sie NaN ein:

Enter a floating-point number or an expression (e.g., 0.0/0.0): NaN
The input resulted in NaN.

Geben Sie hello ein:

Enter a floating-point number or an expression (e.g., 0.0/0.0): hello
Invalid input: Could not parse as a number.

Dieser Schritt zeigt, wie Sie die Eingabeparsing mit der Double.isNaN()-Prüfung kombinieren können, um verschiedene Arten von Eingaben zu behandeln, einschließlich gültiger Zahlen, der Zeichenkette "NaN" und ungültiger Zahlenformate. Dies ist ein umfassenderer Ansatz zur Behandlung potenzieller Probleme bei der Arbeit mit Gleitkommazahlen aus externen Quellen.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man prüft, ob eine Gleitkommazahl in Java "Not a Number" (NaN) ist. Wir haben festgestellt, dass NaN ein spezieller Wert ist, der aus undefinierten oder nicht darstellbaren Berechnungen resultiert, und dass die Standard-Vergleichsoperatoren bei NaN nicht zuverlässig funktionieren.

Wir haben uns speziell auf die Verwendung der Methode Double.isNaN() konzentriert, die die Standard- und empfohlene Methode zur genauen Erkennung von NaN-Werten in Java ist. Wir haben ihre Verwendung anhand von Beispielen demonstriert, die Gleitkommaoperationen umfassen, die NaN und normale numerische Ergebnisse erzeugen.