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

Einführung

In diesem Lab lernen Sie, wie Sie prüfen können, ob ein double-Wert in Java positive oder negative Unendlichkeit darstellt. Dies ist eine entscheidende Fähigkeit, wenn Sie mit Gleitkomma-Rechnungen umgehen, die möglicherweise Ergebnisse außerhalb des standardmäßigen numerischen Bereichs liefern, wie z. B. solche, die eine Division durch Null beinhalten.

Durch praktische Übungen nutzen Sie die Methode Double.isInfinite() zur Identifizierung von unendlichen Werten, erkunden, wie eine Division durch Null zu Unendlichkeit führen kann, und verstehen den Unterschied zwischen unendlichen Werten und NaN (Not-a-Number).

Skills Graph

Verwendung von Double.isInfinite() für die Prüfung

In diesem Schritt lernen wir, wie man prüft, ob ein double-Wert in Java positive oder negative Unendlichkeit darstellt. Dies ist besonders nützlich, wenn man mit Berechnungen umgeht, die möglicherweise Werte außerhalb des normalen Bereichs von Gleitkommazahlen liefern, wie z. B. eine Division durch Null.

Java bietet eine eingebaute Methode namens isInfinite() in der Double-Klasse speziell für diesen Zweck.

Lassen Sie uns ein einfaches Java-Programm erstellen, um zu zeigen, wie man Double.isInfinite() verwendet.

1. Öffnen Sie die Datei HelloJava.java im WebIDE-Editor, wenn sie noch nicht geöffnet ist. Sie sollten sich im Verzeichnis ~/project befinden.

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

   public class HelloJava {
       public static void main(String[] args) {
           double positiveInfinity = Double.POSITIVE_INFINITY;
           double negativeInfinity = Double.NEGATIVE_INFINITY;
           double finiteNumber = 10.0;
   
           System.out.println("Is positiveInfinity infinite? " + Double.isInfinite(positiveInfinity));
           System.out.println("Is negativeInfinity infinite? " + Double.isInfinite(negativeInfinity));
           System.out.println("Is finiteNumber infinite? " + Double.isInfinite(finiteNumber));
       }
   }

   Schauen wir uns die neuen Teile dieses Codes an:

   • double positiveInfinity = Double.POSITIVE_INFINITY;: Diese Zeile deklariert eine double-Variable und weist ihr den speziellen Wert zu, der positive Unendlichkeit darstellt.
   • double negativeInfinity = Double.NEGATIVE_INFINITY;: Diese Zeile deklariert eine double-Variable und weist ihr den speziellen Wert zu, der negative Unendlichkeit darstellt.
   • double finiteNumber = 10.0;: Dies deklariert eine normale double-Variable mit einem endlichen Wert.
   • System.out.println("Is positiveInfinity infinite? " + Double.isInfinite(positiveInfinity));: Diese Zeile ruft die Methode Double.isInfinite() mit positiveInfinity als Argument auf. Die Methode gibt true zurück, wenn der Wert unendlich ist (entweder positiv oder negativ), und false sonst. Das Ergebnis wird dann auf der Konsole ausgegeben.
   • Die nächsten beiden System.out.println-Zeilen tun dasselbe für negativeInfinity und finiteNumber.

3. Speichern Sie die Datei (Strg+S oder Cmd+S).

4. Jetzt lassen Sie uns unser Programm kompilieren. Öffnen Sie das Terminal unten im WebIDE und stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden. Führen Sie den folgenden Befehl aus:

   javac HelloJava.java

   Wenn die Kompilierung erfolgreich ist, sehen Sie keine Ausgabe.

5. Führen Sie schließlich das kompilierte Programm mit dem java-Befehl aus:

   java HelloJava

   Sie sollten eine Ausgabe ähnlich der folgenden sehen:

   Is positiveInfinity infinite? true
   Is negativeInfinity infinite? true
   Is finiteNumber infinite? false

Diese Ausgabe bestätigt, dass Double.isInfinite() sowohl positive als auch negative Unendlichkeit korrekt erkennt, während es für eine normale endliche Zahl false zurückgibt.

Test mit Division durch Null

Im vorherigen Schritt haben wir gesehen, wie Double.isInfinite() mit vordefinierten Unendlichkeitswerten funktioniert. Jetzt wollen wir uns ein häufiges Szenario anschauen, in dem Unendlichkeit in Berechnungen auftreten kann: die Division durch Null.

In der Standardarithmetik ist die Division durch Null undefiniert. In der Gleitkommaarithmetik (die double verwendet) führt jedoch die Division einer von Null verschiedenen Zahl durch Null je nach Vorzeichen des Zählers zu positiver oder negativer Unendlichkeit. Die Division von Null durch Null oder von Unendlichkeit durch Unendlichkeit ergibt einen speziellen Wert namens "Not a Number" (NaN), den wir im nächsten Schritt behandeln werden.

Lassen Sie uns unser Programm ändern, um die Division durch Null zu demonstrieren und das Ergebnis mit Double.isInfinite() zu prüfen.

1. Öffnen Sie die Datei HelloJava.java im WebIDE-Editor. Sie sollten sich im Verzeichnis ~/project befinden.

2. Ersetzen Sie den aktuellen Code durch folgenden:

   public class HelloJava {
       public static void main(String[] args) {
           double positiveResult = 10.0 / 0.0;
           double negativeResult = -10.0 / 0.0;
           double zeroResult = 0.0 / 10.0;
   
           System.out.println("Result of 10.0 / 0.0: " + positiveResult);
           System.out.println("Is 10.0 / 0.0 infinite? " + Double.isInfinite(positiveResult));
   
           System.out.println("Result of -10.0 / 0.0: " + negativeResult);
           System.out.println("Is -10.0 / 0.0 infinite? " + Double.isInfinite(negativeResult));
   
           System.out.println("Result of 0.0 / 10.0: " + zeroResult);
           System.out.println("Is 0.0 / 10.0 infinite? " + Double.isInfinite(zeroResult));
       }
   }

   Hier ist, was in diesem neuen Code passiert:

   • double positiveResult = 10.0 / 0.0;: Wir teilen eine positive Zahl (10.0) durch Null (0.0). In der Gleitkommaarithmetik ergibt dies positive Unendlichkeit.
   • double negativeResult = -10.0 / 0.0;: Wir teilen eine negative Zahl (-10.0) durch Null (0.0). Dies ergibt negative Unendlichkeit.
   • double zeroResult = 0.0 / 10.0;: Wir teilen Null (0.0) durch eine von Null verschiedene Zahl (10.0). Dies ergibt Null, was eine endliche Zahl ist.
   • Dann geben wir die Ergebnisse dieser Divisionen aus und verwenden Double.isInfinite(), um zu prüfen, ob jedes Ergebnis unendlich ist.

3. Speichern Sie die Datei (Strg+S oder Cmd+S).

4. Kompilieren Sie das geänderte Programm im Terminal:

   javac HelloJava.java

   Wiederum bedeutet die fehlende Ausgabe, dass die Kompilierung erfolgreich war.

5. Führen Sie das Programm aus:

   java HelloJava

   Sie sollten eine Ausgabe ähnlich der folgenden sehen:

   Result of 10.0 / 0.0: Infinity
   Is 10.0 / 0.0 infinite? true
   Result of -10.0 / 0.0: -Infinity
   Is -10.0 / 0.0 infinite? true
   Result of 0.0 / 10.0: 0.0
   Is 0.0 / 10.0 infinite? false

Dies zeigt, dass die Division einer von Null verschiedenen Gleitkommazahl durch Null korrekt Unendlichkeit (positiv oder negativ) ergibt und Double.isInfinite() diese Ergebnisse genau erkennt. Die Division von Null durch eine von Null verschiedene Zahl ergibt Null, was nicht unendlich ist.

Unterscheidung zwischen Unendlichkeit und NaN

In den vorherigen Schritten haben wir über Double.isInfinite() gelernt und wie die Division durch Null zu Unendlichkeit führen kann. Es gibt jedoch einen weiteren speziellen Wert in der Gleitkommaarithmetik namens NaN, was für "Not a Number" steht. NaN repräsentiert das Ergebnis einer undefinierten oder nicht darstellbaren Operation, wie z. B. die Division von Null durch Null oder die Wurzel aus einer negativen Zahl.

Es ist wichtig, zwischen unendlichen Werten und NaN unterscheiden zu können, da sie verschiedene Arten von Ausnahmeresultaten darstellen. Java bietet die Methode Double.isNaN(), um zu prüfen, ob ein double-Wert NaN ist.

Lassen Sie uns unser Programm ein letztes Mal ändern, um eine Berechnung einzubeziehen, die NaN ergibt, und zu sehen, wie man es von Unendlichkeit unterscheidet.

1. Öffnen Sie die Datei HelloJava.java im WebIDE-Editor. Sie sollten sich im Verzeichnis ~/project befinden.

2. Ersetzen Sie den aktuellen Code durch folgenden:

   public class HelloJava {
       public static void main(String[] args) {
           double positiveInfinity = 10.0 / 0.0;
           double nanResult = 0.0 / 0.0;
           double finiteNumber = 5.0;
   
           System.out.println("Result of 10.0 / 0.0: " + positiveInfinity);
           System.out.println("Is 10.0 / 0.0 infinite? " + Double.isInfinite(positiveInfinity));
           System.out.println("Is 10.0 / 0.0 NaN? " + Double.isNaN(positiveInfinity));
   
           System.out.println("Result of 0.0 / 0.0: " + nanResult);
           System.out.println("Is 0.0 / 0.0 infinite? " + Double.isInfinite(nanResult));
           System.out.println("Is 0.0 / 0.0 NaN? " + Double.isNaN(nanResult));
   
           System.out.println("Result of 5.0: " + finiteNumber);
           System.out.println("Is 5.0 infinite? " + Double.isInfinite(finiteNumber));
           System.out.println("Is 5.0 NaN? " + Double.isNaN(finiteNumber));
       }
   }

   Hier ist eine Zusammenfassung der Änderungen:

   • double positiveInfinity = 10.0 / 0.0;: Wir behalten die Division bei, die zu positiver Unendlichkeit führt.
   • double nanResult = 0.0 / 0.0;: Diese Zeile führt die Division von Null durch Null durch, was NaN ergibt.
   • double finiteNumber = 5.0;: Eine normale endliche Zahl zum Vergleich.
   • Wir rufen jetzt für jedes Ergebnis neben Double.isInfinite() auch Double.isNaN() auf.

3. Speichern Sie die Datei (Strg+S oder Cmd+S).

4. Kompilieren Sie das Programm im Terminal:

   javac HelloJava.java

5. Führen Sie das Programm aus:

   java HelloJava

   Sie sollten eine Ausgabe ähnlich der folgenden sehen:

   Result of 10.0 / 0.0: Infinity
   Is 10.0 / 0.0 infinite? true
   Is 10.0 / 0.0 NaN? false
   Result of 0.0 / 0.0: NaN
   Is 0.0 / 0.0 infinite? false
   Is 0.0 / 0.0 NaN? true
   Result of 5.0: 5.0
   Is 5.0 infinite? false
   Is 5.0 NaN? false

Diese Ausgabe zeigt deutlich den Unterschied zwischen unendlichen Werten und NaN. Double.isInfinite() gibt nur für positive oder negative Unendlichkeit true zurück, während Double.isNaN() nur für NaN true zurückgibt. Für eine endliche Zahl geben beide Methoden false zurück. Das Verständnis dieser Unterscheidung ist entscheidend für die Behandlung möglicher Fehler und unerwarteter Ergebnisse in Gleitkomma-Berechnungen.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man prüft, ob ein double-Wert in Java positive oder negative Unendlichkeit darstellt, indem man die Methode Double.isInfinite() verwendet. Wir haben gesehen, wie man diese Methode mit den vordefinierten Werten Double.POSITIVE_INFINITY und Double.NEGATIVE_INFINITY sowie mit einer endlichen Zahl verwendet, um ihr Verhalten zu verstehen. Diese Methode ist entscheidend für die Behandlung möglicher unendlicher Ergebnisse aus Gleitkomma-Berechnungen.