如何在 Java 中检查对象是否为 null

简介

在这个实验中，你将学习在 Java 中检查对象是否为 null 的基本技术，这是防止 NullPointerException 错误的一项基本技能。我们将从探索最基本的方法开始：使用相等运算符 (==) 直接将引用变量与 null 进行比较。

在此基础上，我们将研究如何将空值检查与类型检查相结合，以确保对象的存在及其类型的正确性。最后，我们将深入探讨 Optional 类的使用，这是 Java 的一项现代特性，它提供了一种更符合习惯且更安全的方式来处理可能为 null 的值，有助于编写更健壮、更易读的代码。

Skills Graph

使用相等运算符进行空值检查

在这一步中，我们将探索在 Java 中检查 null 的最基本方法之一：使用相等运算符 (==)。理解如何处理 null 在 Java 编程中至关重要，可避免出现错误。

在 Java 中，null 是一个特殊值，表示引用变量不指向任何对象。你可以把变量想象成一个盒子，而对象则是你放在盒子里的东西。如果盒子是空的，那么这个变量就是 null。尝试使用 null 引用（就像试图从一个空盒子里拿东西）通常会导致 NullPointerException，这是初学者常见且头疼的错误。

让我们创建一个简单的 Java 程序，来演示如何使用相等运算符检查 null。

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

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

   public class HelloJava {
       public static void main(String[] args) {
           String message = null; // Declaring a String variable and setting it to null
   
           // Checking if the message variable is null using the equality operator
           if (message == null) {
               System.out.println("The message is null.");
           } else {
               System.out.println("The message is: " + message);
           }
   
           message = "Hello, World!"; // Assigning a String object to the variable
   
           // Checking again after assigning a value
           if (message == null) {
               System.out.println("The message is null.");
           } else {
               System.out.println("The message is: " + message);
           }
       }
   }

   在这段代码中：

   • 我们声明了一个名为 message 的 String 变量，并将其初始值设为 null。
   • 我们使用 if 语句和相等运算符 (==) 来检查 message 是否为 null。
   • 如果 message == null 为真，我们打印 "The message is null."。
   • 如果为假，我们打印消息本身。
   • 然后，我们将字符串 "Hello, World!" 赋值给 message 变量。
   • 我们再次进行 null 检查，以查看不同的输出。

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

4. 在终端中使用 javac 命令编译程序：

   javac HelloJava.java

   如果没有错误，编译就成功了。

5. 使用 java 命令运行编译后的程序：

   java HelloJava

   你应该会看到以下输出：

   The message is null.
   The message is: Hello, World!

   这个输出证实了我们使用 == 进行的 null 检查是正确的。当 message 为 null 时，第一个 if 条件为真。在我们赋值之后，第二个 if 条件为假，于是执行了 else 块。

在 Java 中，使用相等运算符 (==) 是检查引用变量是否为 null 的标准且推荐的方法。它简单、清晰且高效。

结合空值检查和类型检查

在这一步中，你将学习如何将检查对象是否为 null 与检查对象的类型结合起来。当你接收到一个对象，并且需要在使用它之前确保它不为 null 且属于特定类型时，这是一种常见的情况。

Java 提供了 instanceof 运算符来检查一个对象是否是某个特定类的实例，或者是否实现了某个特定接口。你可以使用逻辑与运算符 (&&) 将其与空值检查结合起来。

让我们修改 HelloJava.java 程序来演示这一点。

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

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

   public class HelloJava {
       public static void main(String[] args) {
           Object myObject = "This is a String"; // Declaring an Object variable
   
           // Checking if myObject is not null AND is an instance of String
           if (myObject != null && myObject instanceof String) {
               String message = (String) myObject; // Casting the Object to a String
               System.out.println("The object is a non-null String: " + message);
           } else {
               System.out.println("The object is null or not a String.");
           }
   
           myObject = null; // Setting the object to null
   
           // Checking again after setting to null
           if (myObject != null && myObject instanceof String) {
               String message = (String) myObject;
               System.out.println("The object is a non-null String: " + message);
           } else {
               System.out.println("The object is null or not a String.");
           }
   
           myObject = 123; // Setting the object to an Integer
   
           // Checking again after setting to an Integer
           if (myObject != null && myObject instanceof String) {
               String message = (String) myObject;
               System.out.println("The object is a non-null String: " + message);
           } else {
               System.out.println("The object is null or not a String.");
           }
       }
   }

   在这段更新后的代码中：

   • 你声明了一个类型为 Object 的变量 myObject。Object 是 Java 中所有类的基类，因此它可以持有任何对象的引用。
   • 首先，你将一个 String 赋值给 myObject。
   • if 条件 myObject != null && myObject instanceof String 检查两件事：
     • myObject != null：对象引用是否不为 null？
     • myObject instanceof String：对象是否是 String 类的实例？
   • && 运算符表示两个条件都必须为真，if 块内的代码才会执行。
   • 如果两个条件都为真，你使用 (String) myObject 将 myObject 强制转换为 String 类型，并打印一条消息。进行强制类型转换是必要的，因为 myObject 被声明为 Object 类型，你需要告诉编译器你知道它实际上是一个 String，这样才能将其当作 String 来处理。
   • 如果任何一个条件为假（对象为 null 或不是 String 类型），则执行 else 块。
   • 然后，你将 myObject 设置为 null，再设置为 Integer 类型（它不是 String 类型），并再次测试 if 条件。

3. 保存文件。

4. 编译程序：

   javac HelloJava.java

5. 运行程序：

   java HelloJava

   你应该会看到以下输出：

   The object is a non-null String: This is a String
   The object is null or not a String.
   The object is null or not a String.

   这个输出表明，if 条件能够正确识别对象何时是一个非空的 String，以及何时对象为 null 或不是 String 类型。

当你需要安全地处理可能为 null 的特定类型的对象时，结合使用 != null 和 instanceof 是 Java 中的一种标准模式。

使用 Optional 处理空值

在这一步中，我们将探索 Java 8 引入的一种更现代的处理潜在 null 值的方法：Optional 类。Optional 是一个容器对象，它可能包含也可能不包含非空值。它提供了一种更明确地表示值是否存在的方式，有助于降低 NullPointerException 的风险。

使用 Optional 能促使你考虑值可能不存在的情况，并优雅地处理这种情况，而不是依赖于在代码中分散的 null 检查。

让我们修改 HelloJava.java 程序以使用 Optional。

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

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

   import java.util.Optional;
   
   public class HelloJava {
       public static void main(String[] args) {
           // Creating an Optional that contains a value
           Optional<String> optionalMessageWithValue = Optional.of("Hello from Optional!");
   
           // Creating an Optional that is empty (represents null)
           Optional<String> optionalMessageWithoutValue = Optional.empty();
   
           // Handling the Optional with a value
           if (optionalMessageWithValue.isPresent()) {
               String message = optionalMessageWithValue.get(); // Get the value if present
               System.out.println("Optional with value: " + message);
           } else {
               System.out.println("Optional with value is empty.");
           }
   
           // Handling the Optional without a value
           if (optionalMessageWithoutValue.isPresent()) {
               String message = optionalMessageWithoutValue.get();
               System.out.println("Optional without value: " + message);
           } else {
               System.out.println("Optional without value is empty.");
           }
   
           // A more concise way to handle Optional using ifPresent
           optionalMessageWithValue.ifPresent(msg -> System.out.println("Using ifPresent: " + msg));
   
           // Using orElse to provide a default value if Optional is empty
           String messageOrDefault = optionalMessageWithoutValue.orElse("Default Message");
           System.out.println("Using orElse: " + messageOrDefault);
       }
   }

   在这段代码中：

   • 我们导入了 Optional 类。
   • 我们使用 Optional.of() 创建了一个包含值的 Optional<String>。请注意，如果将 null 传递给 Optional.of()，它会抛出 NullPointerException。如果值可能为 null，则应使用 Optional.ofNullable()。
   • 我们使用 Optional.empty() 创建了一个空的 Optional<String>。
   • 我们使用 optionalMessageWithValue.isPresent() 检查 Optional 是否包含值。如果包含，我们可以使用 optionalMessageWithValue.get() 来获取该值。注意：对空的 Optional 调用 get() 会抛出 NoSuchElementException。
   • 我们以类似的方式演示了如何处理空的 Optional。
   • 我们展示了 ifPresent() 方法，它仅在值存在时执行给定的操作。这是一种更简洁的方式来对存在的值执行操作。
   • 我们展示了 orElse() 方法，它在值存在时返回该值，否则返回一个默认值。这对于提供备用值很有用。

3. 保存文件。

4. 编译程序：

   javac HelloJava.java

5. 运行程序：

   java HelloJava

   你应该会看到以下输出：

   Optional with value: Hello from Optional!
   Optional without value is empty.
   Using ifPresent: Hello from Optional!
   Using orElse: Default Message

   这个输出展示了与传统的 null 检查相比，Optional 如何更明确、更安全地处理值的存在或缺失。虽然 Optional 不能替代所有的 null 检查，但在设计 API 和编写代码时，当值的缺失是一种有效且预期的情况时，它是一个很有价值的工具。

总结

在本次实验中，你学习了在 Java 中检查对象是否为 null 的基本技术。首先，你探索了最基本的方法：使用相等运算符 (==) 直接将引用变量与 null 进行比较。这种简单的检查对于防止 NullPointerException 错误至关重要。

接着，你进入了更高级的场景，不过提供的内容仅详细介绍了基本的相等检查。一个完整的实验可能会涵盖将空值检查与类型检查相结合，以及使用 Optional 类。Optional 类是 Java 的一项现代特性，旨在更优雅、更清晰地处理潜在的空值，有助于编写更简洁、更安全的代码。