如何在 Java 中检查数字是否为零

简介

在这个实验中，你将学习如何在 Java 中检查一个数字是否为零。这项基础技能对于使用条件语句控制程序流程至关重要。我们将首先探讨如何使用相等运算符 (==) 来将整数值与零进行比较。

接着，由于精度问题，我们将讨论在处理浮点数和零的比较时需要特别考虑的因素以及可能遇到的陷阱。最后，我们将研究在使用 Java 中基本数据类型的包装类时如何进行零检查。

Skills Graph

使用相等运算符检查是否为零

在这一步中，我们将探讨如何在 Java 中使用相等运算符来检查一个数字是否等于零。这是编程中的一项基本操作，常用于条件语句中以控制程序的流程。

在 Java 中，相等运算符用 == 表示。它用于比较两个值，如果它们相等则返回 true，否则返回 false。

让我们创建一个简单的 Java 程序来演示这一点。

1. 如果 HelloJava.java 文件尚未在 WebIDE 编辑器中打开，请打开它。

2. 将文件的全部内容替换为以下代码：

   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.");
           }
       }
   }

   让我们来分析一下这段新代码：

   • int number = 0;：这一行声明了一个名为 number 的整数变量，并将其初始值设为 0。
   • if (number == 0)：这是一个 if 语句，用于在代码中进行决策。括号内的条件 (number == 0) 检查 number 变量的值是否等于 0。
   • System.out.println("The number is zero.");：只有当条件 number == 0 为 true 时，才会执行这一行。
   • else：这个关键字引入了一个代码块，当 if 条件为 false 时，将执行该代码块。
   • System.out.println("The number is not zero.");：只有当条件 number == 0 为 false 时，才会执行这一行。

3. 保存文件（Ctrl+S 或 Cmd+S）。

4. 现在，让我们编译修改后的程序。在终端中，确保你位于 ~/project 目录下。如果需要，可以使用 cd ~/project 命令。然后，运行以下命令：

   javac HelloJava.java

   如果编译成功，你将不会看到任何输出。

5. 最后，让我们运行程序：

   java HelloJava

   你应该会看到以下输出：

   The number is zero.

   这证实了我们的程序使用 == 运算符正确地检查了 number 变量是否等于零。

现在，尝试将 number 变量的值更改为非零值（例如 int number = 5;），保存文件，重新编译并再次运行程序，以查看不同的输出。

处理浮点数精度问题

在这一步中，我们将探讨编程中处理浮点数（带小数点的数字）时常见的一个问题：精度。由于计算机存储这些数字的方式，使用 == 进行直接的相等性比较有时会导致意外的结果。

让我们来实际看看这个问题。

1. 在 WebIDE 编辑器中打开 HelloJava.java 文件。

2. 将现有代码替换为以下内容：

   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.");
           }
       }
   }

   在这段代码中：

   • 我们声明了两个 double 类型的变量 num1 和 num2。double 是 Java 中用于存储浮点数的数据类型。
   • 我们将 0.1 + 0.2 赋值给 num1，将 0.3 赋值给 num2。从数学角度看，它们应该相等。
   • 我们打印出 num1 和 num2 的值，以查看它们的精确表示。
   • 我们使用 == 运算符来检查 num1 是否等于 num2。

3. 保存文件（Ctrl+S 或 Cmd+S）。

4. 在终端中编译程序：

   javac HelloJava.java

5. 运行编译后的程序：

   java HelloJava

   你可能会对输出结果感到惊讶：

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

   如你所见，由于浮点数的存储方式，num1 并不精确等于 0.3。这是一个常见问题，也是为什么通常不建议使用 == 直接比较浮点数是否相等的原因。

为了处理这个问题，我们通常不检查精确相等性，而是检查两个数字之间的绝对差值是否在一个非常小的容差范围内（通常称为“epsilon”）。

让我们修改代码以采用这种方法。

1. 再次打开 HelloJava.java 文件。

2. 将 if 语句替换为以下内容：

   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.");
   }

   这里：

   • 我们定义了一个小的 epsilon 值。
   • Math.abs(num1 - num2) 计算 num1 和 num2 之间的绝对差值。
   • 我们检查这个绝对差值是否小于我们定义的 epsilon。

3. 保存文件。

4. 编译程序：

   javac HelloJava.java

5. 运行程序：

   java HelloJava

   现在输出应该是：

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

   这展示了在考虑精度限制的情况下，比较浮点数是否近似相等的正确方法。

使用包装类进行测试

在这一步中，我们将探讨 Java 包装类的相等性比较机制。包装类是特殊的类，它提供了一种将基本数据类型（如 int、double、boolean）当作对象使用的方式。例如，int 的包装类是 Integer，double 的包装类是 Double。

在 Java 中比较对象时，== 运算符检查的是两个变量是否引用内存中的 同一个对象，而非它们的值是否相等。若要比较对象的 值，你应该使用 equals() 方法。

让我们看看这在包装类中是如何应用的。

1. 在 WebIDE 编辑器中打开 HelloJava.java 文件。

2. 将现有代码替换为以下内容：

   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");
           }
       }
   }

   在这段代码中：

   • 我们使用 new Integer() 创建了两个 Integer 对象 intObj1 和 intObj2，它们的值相同（均为 100）。这会在内存中创建两个不同的对象。
   • 我们创建了 intObj3 并将 intObj1 赋值给它。这意味着 intObj3 和 intObj1 现在指向内存中的 同一个 对象。
   • 我们使用 == 来比较 intObj1 与 intObj2 以及 intObj3。
   • 我们使用 equals() 方法来比较 intObj1 与 intObj2 以及 intObj3 的 值。

3. 保存文件（Ctrl+S 或 Cmd+S）。

4. 在终端中编译程序：

   javac HelloJava.java

5. 运行编译后的程序：

   java HelloJava

   输出结果应该如下：

   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

   这个输出清晰地展示了其中的差异：

   • intObj1 == intObj2 为 false，因为它们是内存中的不同对象，尽管它们的值相同。
   • intObj1 == intObj3 为 true，因为它们引用的是同一个对象。
   • intObj1.equals(intObj2) 为 true，因为 equals() 方法比较的是对象的 值，而它们的值都是 100。
   • intObj1.equals(intObj3) 同样为 true，因为它们引用同一个对象，且值相同。

   重要提示：对于小整数值（通常是 -128 到 127），Java 会为 Integer 对象使用缓存。这意味着 Integer intObjA = 50; Integer intObjB = 50; 可能会使 intObjA == intObjB 为 true，因为它们可能引用同一个缓存对象。不过，不建议依赖这种缓存行为进行相等性检查。始终使用 equals() 方法来比较包装类对象的值。

这一步凸显了 Java 中比较基本类型和对象的关键差异，以及使用 equals() 方法进行对象值比较的重要性。

总结

在本次实验中，我们学习了如何在 Java 中检查一个数字是否为零。首先，我们使用基本的相等运算符 (==) 在 if 语句中比较一个整数变量和零，这展示了基于数值相等性进行条件检查的基本原理。

接着，我们探讨了处理浮点数的细微差别，以及使用 == 将浮点数直接与零进行比较时可能出现的精度问题。最后，我们研究了如何使用 Java 的包装类进行零检查，了解了如何访问和比较底层的基本数据类型值。