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

简介

在这个实验中，你将学习如何在 Java 中安全地处理 Integer 包装类对象，特别关注如何检查它们是否为 null。与基本数据类型 int 不同，Integer 是一个可以持有 null 引用的对象，如果不检查 null，可能会导致常见的 NullPointerException 错误。

通过实际示例，你将探索基本的 == null 检查，将空值检查与值比较相结合，最后，学习如何利用 Optional 类在你的 Java 代码中进行更健壮、更具表现力的空值处理。

Skills Graph

测试 Integer 包装类是否为 Null

在这一步中，我们将探讨如何在 Java 中处理 Integer 包装类对象，特别关注如何检查它们是否为 null。与 int 等基本数据类型不同，Integer 是一个类，这意味着 Integer 变量可以持有一个对象的引用，或者如果它不引用任何对象，则可以为 null。在 Java 中处理 null 值对于防止 NullPointerException 错误至关重要，这种错误非常常见，可能会导致你的程序崩溃。

让我们创建一个简单的 Java 程序来演示如何检查 Integer 是否为 null。

1. 在 WebIDE 编辑器中打开 HelloJava.java 文件。如果你完成了上一个实验，该文件应该已经存在于 ~/project 目录中。

2. 将 HelloJava.java 中的现有代码替换为以下内容：

   public class HelloJava {
       public static void main(String[] args) {
           Integer myInteger = null; // Declaring an Integer and setting it to null
   
           // Check if myInteger is null
           if (myInteger == null) {
               System.out.println("myInteger is null.");
           } else {
               System.out.println("myInteger is not null. Its value is: " + myInteger);
           }
   
           // Let's try with a non-null Integer
           Integer anotherInteger = 10; // Declaring and initializing with a value
   
           // Check if anotherInteger is null
           if (anotherInteger == null) {
               System.out.println("anotherInteger is null.");
           } else {
               System.out.println("anotherInteger is not null. Its value is: " + anotherInteger);
           }
       }
   }

   在这段代码中：

   • 我们声明了一个 Integer 变量 myInteger，并将其显式设置为 null。
   • 我们使用 if 语句和 == 运算符来检查 myInteger 是否等于 null。这是在 Java 中检查对象引用是否为 null 的标准方法。
   • 然后，我们声明另一个 Integer 变量 anotherInteger，并将其赋值为 10。Java 会自动将基本数据类型 int 的值 10 转换为 Integer 对象（这称为自动装箱）。
   • 我们对 anotherInteger 执行相同的 null 检查。

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

4. 现在，在终端中使用 javac 命令编译程序。确保你位于 ~/project 目录中。

   javac HelloJava.java

   如果没有错误，编译将无声完成，并且会在 ~/project 目录中创建一个 HelloJava.class 文件。

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

   java HelloJava

   你应该会看到类似以下的输出：

   myInteger is null.
   anotherInteger is not null. Its value is: 10

   此输出确认我们的 null 检查对于 null 的 Integer 和非 null 的 Integer 都能正常工作。理解如何检查 null 是 Java 编程中的一项基本技能，特别是在处理包装类和可能并不总是有赋值的对象时。

结合空值和值检查

在上一步中，我们学习了如何检查 Integer 对象是否为 null。通常，你需要检查一个 Integer 是否不为 null，并且其值是否满足特定条件。将这些检查结合起来非常重要，因为尝试访问 null 的 Integer 的值会导致 NullPointerException。

让我们修改程序，以演示如何将 null 检查与值检查结合起来。

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

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

   public class HelloJava {
       public static void main(String[] args) {
           Integer score = null; // Example 1: score is null
   
           // Check if score is not null AND its value is greater than 50
           if (score != null && score > 50) {
               System.out.println("Score is not null and is greater than 50.");
           } else {
               System.out.println("Score is null or not greater than 50.");
           }
   
           Integer anotherScore = 75; // Example 2: score is 75
   
           // Check if anotherScore is not null AND its value is greater than 50
           if (anotherScore != null && anotherScore > 50) {
               System.out.println("anotherScore is not null and is greater than 50.");
           } else {
               System.out.println("anotherScore is null or not greater than 50.");
           }
   
           Integer yetAnotherScore = 40; // Example 3: score is 40
   
           // Check if yetAnotherScore is not null AND its value is greater than 50
           if (yetAnotherScore != null && yetAnotherScore > 50) {
               System.out.println("yetAnotherScore is not null and is greater than 50.");
           } else {
               System.out.println("yetAnotherScore is null or not greater than 50.");
           }
       }
   }

   在这个更新后的代码中：

   • 我们使用逻辑与运算符 (&&) 来组合两个条件：score != null 和 score > 50。
   • score != null 检查放在首位。在 Java 中，&& 运算符采用短路求值。这意味着如果第一个条件 (score != null) 为假，则不会计算第二个条件 (score > 50)。当 score 为 null 时，这可以防止 NullPointerException，因为代码 score > 50 不会被执行。
   • 我们使用三个不同的 Integer 变量来测试这个逻辑：一个为 null，一个不为 null 且大于 50，一个不为 null 但不大于 50。

3. 保存 HelloJava.java 文件。

4. 在终端中编译修改后的程序：

   javac HelloJava.java

5. 运行编译后的程序：

   java HelloJava

   你应该会看到类似以下的输出：

   Score is null or not greater than 50.
   anotherScore is not null and is greater than 50.
   yetAnotherScore is null or not greater than 50.

   这个输出展示了组合检查是如何工作的。第一种情况正确识别出 score 为 null。第二种情况识别出 anotherScore 不为 null 且大于 50。第三种情况识别出 yetAnotherScore 不大于 50，即使它不为 null。在访问对象的属性或值之前检查 null，这种模式是 Java 中的一项基本安全实践。

使用 Optional 进行安全处理

虽然使用 == null 检查 null 并结合 && 进行组合检查是有效的，但 Java 8 引入了 Optional 类，作为一种更符合习惯用法的方式来处理可能缺失（即 null）的值。Optional 是一个容器对象，它可能包含也可能不包含非 null 值。使用 Optional 可以使你的代码更具可读性，并且更不容易出现 NullPointerException 错误。

在这一步中，我们将重构程序，使用 Optional<Integer> 来处理可能缺失的整数值。

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

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

   import java.util.Optional;
   
   public class HelloJava {
       public static void main(String[] args) {
           // Example 1: Optional containing a null value (empty Optional)
           Optional<Integer> optionalScoreNull = Optional.empty();
   
           // Check if the Optional contains a value and if it's greater than 50
           if (optionalScoreNull.isPresent() && optionalScoreNull.get() > 50) {
                System.out.println("optionalScoreNull is present and greater than 50.");
           } else {
                System.out.println("optionalScoreNull is empty or not greater than 50.");
           }
   
           // Example 2: Optional containing a non-null value (75)
           Optional<Integer> optionalScorePresent = Optional.of(75);
   
           // Check if the Optional contains a value and if it's greater than 50
           if (optionalScorePresent.isPresent() && optionalScorePresent.get() > 50) {
                System.out.println("optionalScorePresent is present and greater than 50.");
           } else {
                System.out.println("optionalScorePresent is empty or not greater than 50.");
           }
   
           // Example 3: Optional containing a non-null value (40)
           Optional<Integer> optionalScoreNotGreater = Optional.of(40);
   
           // Check if the Optional contains a value and if it's greater than 50
           if (optionalScoreNotGreater.isPresent() && optionalScoreNotGreater.get() > 50) {
                System.out.println("optionalScoreNotGreater is present and greater than 50.");
           } else {
                System.out.println("optionalScoreNotGreater is empty or not greater than 50.");
           }
   
           // A more functional way using Optional methods
           System.out.println("\nUsing Optional methods:");
   
           optionalScoreNull.ifPresent(value -> System.out.println("Value from optionalScoreNull: " + value));
           optionalScorePresent.ifPresent(value -> System.out.println("Value from optionalScorePresent: " + value));
           optionalScoreNotGreater.ifPresent(value -> System.out.println("Value from optionalScoreNotGreater: " + value));
   
           // Using orElse to provide a default value if Optional is empty
           Integer scoreOrDefault = optionalScoreNull.orElse(0);
           System.out.println("Value from optionalScoreNull with default: " + scoreOrDefault);
   
           // Using filter for conditional checks
           optionalScorePresent.filter(value -> value > 50)
                               .ifPresent(value -> System.out.println("Filtered optionalScorePresent value: " + value));
   
            optionalScoreNotGreater.filter(value -> value > 50)
                               .ifPresent(value -> System.out.println("Filtered optionalScoreNotGreater value: " + value));
       }
   }

   让我们看看主要的更改：

   • import java.util.Optional;：我们导入 Optional 类。
   • Optional<Integer> optionalScoreNull = Optional.empty();：我们创建一个空的 Optional 来表示值的缺失。
   • Optional<Integer> optionalScorePresent = Optional.of(75);：我们使用 Optional.of() 创建一个包含非 null 值的 Optional。请注意，如果传递 null 值，Optional.of() 会抛出 NullPointerException。如果值可能为 null，请使用 Optional.ofNullable()。
   • optionalScoreNull.isPresent()：此方法检查 Optional 是否包含值。这是推荐的检查值是否存在的方式，而不是检查 null。
   • optionalScoreNull.get()：此方法从 Optional 中获取值。要小心！ 如果 Optional 为空，调用 get() 会抛出 NoSuchElementException。这就是为什么在调用 get() 之前应该始终检查 isPresent()，或者使用其他能优雅处理空值情况的 Optional 方法。
   • optionalScoreNull.ifPresent(value -> ...)：此方法仅在 Optional 包含值时执行提供的代码。如果值存在，这是对其执行操作的简洁方式。
   • optionalScoreNull.orElse(0)：此方法如果值存在则返回该值，否则返回指定的默认值（这里是 0）。
   • optionalScorePresent.filter(value -> value > 50)：此方法如果值存在且满足给定条件（值 > 50），则返回包含该值的 Optional，否则返回一个空的 Optional。

3. 保存 HelloJava.java 文件。

4. 在终端中编译程序：

   javac HelloJava.java

5. 运行编译后的程序：

   java HelloJava

   你应该会看到类似以下的输出：

   optionalScoreNull is empty or not greater than 50.
   optionalScorePresent is present and greater than 50.
   optionalScoreNotGreater is empty or not greater than 50.
   
   Using Optional methods:
   Value from optionalScorePresent: 75
   Value from optionalScoreNotGreater: 40
   Value from optionalScoreNull with default: 0
   Filtered optionalScorePresent value: 75

   此输出展示了如何使用 Optional 来处理值的存在或缺失，并安全地执行操作。虽然 if (isPresent() && get() > 50) 模式与 null 检查类似，但 Optional 提供了许多其他有用的方法（ifPresent、orElse、filter、map 等），在处理可能缺失的值时，可以使代码更具表现力和安全性。在现代 Java 开发中，使用 Optional 是一种良好的实践。

总结

在这个实验中，我们学习了如何在 Java 中检查 Integer 包装对象是否为 null。首先，我们了解到 Integer 是一个类，与基本数据类型 int 不同，它可以持有 null 引用。我们通过一个简单的 Java 程序演示了基本的 == null 检查，展示了如何处理 null 和非 null 的 Integer 变量，以防止出现 NullPointerException。