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

Einführung

In diesem Lab lernen Sie, wie Sie in Java prüfen können, ob eine Zahl null ist. Diese grundlegende Fähigkeit ist entscheidend für die Steuerung des Programmablaufs mithilfe von bedingten Anweisungen. Wir beginnen damit, die Verwendung des Gleichheitsoperators (==) zur Vergleich von ganzzahligen Werten mit null zu untersuchen.

Danach werden wir die speziellen Überlegungen und potenziellen Fallstricke behandeln, die bei der Arbeit mit Fließkommazahlen und null aufgrund von Genauigkeitsproblemen auftreten können. Abschließend werden wir untersuchen, wie man Nullprüfungen durchführt, wenn man mit Java's Wrapper-Klassen für primitive Datentypen arbeitet.

Skills Graph

Verwendung des Gleichheitsoperators für Null

In diesem Schritt werden wir untersuchen, wie man in Java prüft, ob eine Zahl gleich null ist, indem man den Gleichheitsoperator verwendet. Dies ist eine grundlegende Operation in der Programmierung, die oft in bedingten Anweisungen verwendet wird, um den Programmablauf zu steuern.

In Java wird der Gleichheitsoperator durch == dargestellt. Er wird verwendet, um zwei Werte zu vergleichen und gibt true zurück, wenn sie gleich sind, und false sonst.

Lassen Sie uns ein einfaches Java-Programm erstellen, um dies zu demonstrieren.

1. Öffnen Sie die Datei HelloJava.java im WebIDE-Editor, wenn sie noch nicht geöffnet ist.

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

   public class HelloJava {
       public static void main(String[] args) {
           int number = 0;
   
           if (number == 0) {
               System.out.println("The number is zero.");
           } else {
               System.out.println("The number is not zero.");
           }
       }
   }

   Lassen Sie uns diesen neuen Code analysieren:

   • int number = 0;: Diese Zeile deklariert eine Ganzzahlvariable namens number und initialisiert sie mit dem Wert 0.
   • if (number == 0): Dies ist eine if-Anweisung, die verwendet wird, um Entscheidungen in Ihrem Code zu treffen. Die Bedingung in den Klammern (number == 0) prüft, ob der Wert der Variable number gleich 0 ist.
   • System.out.println("The number is zero.");: Diese Zeile wird nur ausgeführt, wenn die Bedingung number == 0 true ist.
   • else: Dieses Schlüsselwort leitet den Codeblock ein, der ausgeführt wird, wenn die if-Bedingung false ist.
   • System.out.println("The number is not zero.");: Diese Zeile wird nur ausgeführt, wenn die Bedingung number == 0 false ist.

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

4. Jetzt lassen Sie uns unser modifiziertes Programm kompilieren. Stellen Sie im Terminal sicher, dass Sie sich im Verzeichnis ~/project befinden. Sie können cd ~/project verwenden, wenn erforderlich. Führen Sie dann aus:

   javac HelloJava.java

   Wenn die Kompilierung erfolgreich ist, sehen Sie keine Ausgabe.

5. Abschließend lassen Sie uns unser Programm ausführen:

   java HelloJava

   Sie sollten die folgende Ausgabe sehen:

   The number is zero.

   Dies bestätigt, dass unser Programm korrekt geprüft hat, ob die Variable number mit dem ==-Operator gleich null war.

Versuchen Sie nun, den Wert der Variable number auf einen von null verschiedenen Wert zu ändern (z. B. int number = 5;), speichern Sie die Datei, kompilieren Sie erneut und führen Sie das Programm erneut aus, um die andere Ausgabe zu sehen.

Umgang mit Fließkomma-Präzision

In diesem Schritt werden wir ein häufiges Problem bei der Arbeit mit Fließkommazahlen (Zahlen mit Dezimalpunkten) in der Programmierung untersuchen: die Präzision. Aufgrund der Art und Weise, wie Computer diese Zahlen speichern, können direkte Gleichheitsvergleiche mit == manchmal zu unerwarteten Ergebnissen führen.

Lassen Sie uns dies in Aktion sehen.

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

2. Ersetzen Sie den vorhandenen Code durch den folgenden:

   public class HelloJava {
       public static void main(String[] args) {
           double num1 = 0.1 + 0.2;
           double num2 = 0.3;
   
           System.out.println("num1: " + num1);
           System.out.println("num2: " + num2);
   
           if (num1 == num2) {
               System.out.println("num1 is equal to num2.");
           } else {
               System.out.println("num1 is not equal to num2.");
           }
       }
   }

   In diesem Code:

   • Wir deklarieren zwei double-Variablen, num1 und num2. double ist ein Datentyp in Java, der zur Speicherung von Fließkommazahlen verwendet wird.
   • Wir weisen 0.1 + 0.2 num1 und 0.3 num2 zu. Mathematisch sollten diese gleich sein.
   • Wir geben die Werte von num1 und num2 aus, um ihre genaue Darstellung zu sehen.
   • Wir verwenden den ==-Operator, um zu prüfen, ob num1 gleich num2 ist.

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 kompilierte Programm aus:

   java HelloJava

   Sie könnten über die Ausgabe überrascht sein:

   num1: 0.30000000000000004
   num2: 0.3
   num1 is not equal to num2.

   Wie Sie sehen können, ist num1 aufgrund der Art und Weise, wie Fließkommazahlen gespeichert werden, nicht genau 0.3. Dies ist ein häufiges Problem und der Grund, warum das direkte Vergleichen von Fließkommazahlen auf Gleichheit mit == im Allgemeinen nicht empfohlen wird.

Um dies zu behandeln, prüfen wir normalerweise nicht auf exakte Gleichheit, sondern ob die absolute Differenz zwischen den beiden Zahlen innerhalb einer sehr kleinen Toleranz (oft als "Epsilon" bezeichnet) liegt.

Lassen Sie uns den Code ändern, um diesen Ansatz zu verwenden.

1. Öffnen Sie HelloJava.java erneut.

2. Ersetzen Sie die if-Anweisung durch den folgenden Code:

   double epsilon = 0.000001; // A small tolerance
   
   if (Math.abs(num1 - num2) < epsilon) {
       System.out.println("num1 is approximately equal to num2.");
   } else {
       System.out.println("num1 is not approximately equal to num2.");
   }

   Hier:

   • Wir definieren einen kleinen epsilon-Wert.
   • Math.abs(num1 - num2) berechnet die absolute Differenz zwischen num1 und num2.
   • Wir prüfen, ob diese absolute Differenz kleiner als unser epsilon ist.

3. Speichern Sie die Datei.

4. Kompilieren Sie das Programm:

   javac HelloJava.java

5. Führen Sie das Programm aus:

   java HelloJava

   Jetzt sollte die Ausgabe wie folgt sein:

   num1: 0.30000000000000004
   num2: 0.3
   num1 is approximately equal to num2.

   Dies zeigt die korrekte Methode zum Vergleichen von Fließkommazahlen auf praktische Gleichheit unter Berücksichtigung der Präzisionsbeschränkungen.

Test mit Wrapper-Klassen

In diesem Schritt werden wir untersuchen, wie die Gleichheit mit Java's Wrapper-Klassen funktioniert. Wrapper-Klassen sind spezielle Klassen, die es ermöglichen, primitive Datentypen (wie int, double, boolean) als Objekte zu verwenden. Beispielsweise ist die Wrapper-Klasse für int Integer und für double Double.

Wenn man in Java Objekte vergleicht, prüft der ==-Operator, ob die beiden Variablen auf dasselbe exakte Objekt im Speicher verweisen, nicht ob ihre Werte gleich sind. Um die Werte von Objekten zu vergleichen, sollte man die equals()-Methode verwenden.

Lassen Sie uns sehen, wie dies auf Wrapper-Klassen angewendet wird.

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

2. Ersetzen Sie den vorhandenen Code durch den folgenden:

   public class HelloJava {
       public static void main(String[] args) {
           Integer intObj1 = new Integer(100);
           Integer intObj2 = new Integer(100);
           Integer intObj3 = intObj1; // intObj3 refers to the same object as intObj1
   
           System.out.println("Comparing Integer objects with ==:");
           if (intObj1 == intObj2) {
               System.out.println("intObj1 == intObj2 is true");
           } else {
               System.out.println("intObj1 == intObj2 is false");
           }
   
           if (intObj1 == intObj3) {
               System.out.println("intObj1 == intObj3 is true");
           } else {
               System.out.println("intObj1 == intObj3 is false");
           }
   
           System.out.println("\nComparing Integer objects with equals():");
           if (intObj1.equals(intObj2)) {
               System.out.println("intObj1.equals(intObj2) is true");
           } else {
               System.out.println("intObj1.equals(intObj2) is false");
           }
   
           if (intObj1.equals(intObj3)) {
               System.out.println("intObj1.equals(intObj3) is true");
           } else {
               System.out.println("intObj1.equals(intObj3) is false");
           }
       }
   }

   In diesem Code:

   • Wir erstellen zwei Integer-Objekte, intObj1 und intObj2, mit demselben Wert (100) mithilfe von new Integer(). Dies erstellt zwei verschiedene Objekte im Speicher.
   • Wir erstellen intObj3 und weisen ihm intObj1 zu. Das bedeutet, dass intObj3 und intObj1 jetzt auf dasselbe Objekt im Speicher verweisen.
   • Wir verwenden ==, um intObj1 mit intObj2 und intObj3 zu vergleichen.
   • Wir verwenden die equals()-Methode, um die Werte von intObj1 mit intObj2 und intObj3 zu vergleichen.

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 kompilierte Programm aus:

   java HelloJava

   Die Ausgabe sollte wie folgt sein:

   Comparing Integer objects with ==:
   intObj1 == intObj2 is false
   intObj1 == intObj3 is true
   
   Comparing Integer objects with equals():
   intObj1.equals(intObj2) is true
   intObj1.equals(intObj3) is true

   Diese Ausgabe zeigt deutlich den Unterschied:

   • intObj1 == intObj2 ist false, weil es sich um verschiedene Objekte im Speicher handelt, auch wenn ihre Werte gleich sind.
   • intObj1 == intObj3 ist true, weil sie auf dasselbe exakte Objekt verweisen.
   • intObj1.equals(intObj2) ist true, weil die equals()-Methode die Werte der Objekte vergleicht, die beide 100 sind.
   • intObj1.equals(intObj3) ist ebenfalls true, weil sie auf dasselbe Objekt verweisen und ihre Werte gleich sind.

   Wichtiger Hinweis: Für kleine Ganzzahlwerte (typischerweise -128 bis 127) verwendet Java einen Cache für Integer-Objekte. Das bedeutet, dass Integer intObjA = 50; Integer intObjB = 50; möglicherweise dazu führt, dass intObjA == intObjB true ist, weil sie möglicherweise auf dasselbe gecachte Objekt verweisen. Es wird jedoch nicht empfohlen, sich auf dieses Caching-Verhalten für Gleichheitsüberprüfungen zu verlassen. Verwenden Sie immer die equals()-Methode, um die Werte von Wrapper-Klassen-Objekten zu vergleichen.

Dieser Schritt hebt den entscheidenden Unterschied zwischen dem Vergleichen von primitiven Typen und Objekten in Java hervor sowie die Wichtigkeit der Verwendung der equals()-Methode für den Vergleich von Objektwerten.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man in Java prüft, ob eine Zahl null ist. Wir haben begonnen, den grundlegenden Gleichheitsoperator (==) zu verwenden, um eine Ganzzahlvariable innerhalb einer if-Anweisung mit null zu vergleichen. Dies hat das grundlegende Prinzip bedingter Prüfungen auf numerische Gleichheit gezeigt.

Anschließend haben wir die Feinheiten beim Umgang mit Fließkommazahlen und die potenziellen Präzisionsprobleme untersucht, die auftreten, wenn man sie direkt mit null unter Verwendung von == vergleicht. Schließlich haben wir untersucht, wie man Nullprüfungen mit Java's Wrapper-Klassen durchführt und verstanden, wie man die zugrunde liegenden primitiven Werte zugreift und vergleicht.