如何在 Java 中检查布尔变量是否为 true

介绍

在这个实验中，你将学习如何在 Java 中检查一个布尔变量是否为 true。我们将探讨使用相等运算符的基本方法，深入研究如何处理 Boolean 包装类，并讨论如何处理可能的空值。

通过实际操作的示例，你将获得根据布尔值编写条件逻辑的实践经验，确保你的 Java 代码健壮且能有效处理不同的场景。

使用相等运算符进行 true 检查

在这一步中，我们将探讨如何在 Java 中使用相等运算符来检查一个布尔变量是否为 true。虽然这看起来很简单，但理解其中的细微差别对于编写简洁且正确的代码很重要。

在 Java 中，boolean 数据类型可以存储两个值之一：true 或 false。当你有一个布尔变量时，你通常需要检查它的值，以便在程序中做出决策。

检查布尔变量是否为 true 最常见的方法是使用相等运算符 ==。

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

如果 HelloJava.java 文件尚未在 WebIDE 编辑器中打开，请打开它。
将文件的全部内容替换为以下代码：
```
public class HelloJava {
    public static void main(String[] args) {
        boolean isJavaFun = true;

        if (isJavaFun == true) {
            System.out.println("Java is fun!");
        } else {
            System.out.println("Java is not fun.");
        }
    }
}
```
让我们看看这段代码的新部分：
- boolean isJavaFun = true;：这行代码声明了一个名为 isJavaFun 的布尔变量，并将其初始值设为 true。
- if (isJavaFun == true)：这是一个 if 语句。它检查括号内的条件是否为 true。条件 isJavaFun == true 使用相等运算符 == 来比较 isJavaFun 变量的值与布尔字面量 true。
- System.out.println("Java is fun!");：如果条件 isJavaFun == true 为 true，则执行这行代码。
- else：这个关键字引入了一个代码块，如果 if 条件为 false，则执行该代码块。
- System.out.println("Java is not fun.");：如果条件 isJavaFun == true 为 false，则执行这行代码。
保存文件（Ctrl+S 或 Cmd+S）。
在终端中使用 javac 命令编译程序：
```
javac HelloJava.java
```
如果没有错误，~/project 目录下将创建一个 HelloJava.class 文件。
使用 java 命令运行编译后的程序：
```
java HelloJava
```
你应该会看到以下输出：
```
Java is fun!
```
这证实了 if 条件 isJavaFun == true 的计算结果为 true，并打印了相应的消息。

虽然使用 == true 完全有效且易于理解，但在 Java 中，你可以简化对 true 的检查。由于 if 语句已经将括号内的表达式计算为布尔值，你可以直接将布尔变量本身用作条件。

让我们修改代码以使用这种简化的方法：

再次在编辑器中打开 HelloJava.java。

将 if 语句更改为：

if (isJavaFun) {
    System.out.println("Java is fun!");
} else {
    System.out.println("Java is not fun.");
}

注意，我们去掉了 == true。if (isJavaFun) 语句等同于 if (isJavaFun == true)。

保存文件。
编译修改后的程序：
```
javac HelloJava.java
```
再次运行程序：
```
java HelloJava
```
你将得到相同的输出：
```
Java is fun!
```
这表明在 if 条件中直接使用布尔变量是一种更简洁、更符合习惯的检查其是否为 true 的方法。

总之，你可以使用相等运算符 == true 来检查布尔值是否为 true，但更常见、更简洁的方法是直接将布尔变量用作 if 语句的条件。

使用 Boolean 包装类进行测试

在上一步中，我们使用了基本数据类型 boolean。Java 还有一个对应的包装类 Boolean。包装类提供了一种将基本数据类型当作对象使用的方式。当处理集合或者需要表示一个可能为 null 的布尔值时，这尤其有用。

Boolean 类有两个预定义的对象来表示布尔值：Boolean.TRUE 和 Boolean.FALSE。它们分别是代表布尔值 true 和 false 的常量对象。

在处理 Boolean 对象时，你仍然可以使用相等运算符 == 来比较它们。不过，理解 == 对对象的作用方式很重要。对于对象，== 检查的是两个变量是否引用内存中的 同一个对象，而不仅仅是它们的值是否相同。

让我们修改程序以使用 Boolean 包装类，看看相等运算符的表现如何。

在 WebIDE 编辑器中打开 HelloJava.java 文件。
将代码替换为以下内容：
```
public class HelloJava {
    public static void main(String[] args) {
        Boolean isJavaFunObject = Boolean.TRUE;

        if (isJavaFunObject == Boolean.TRUE) {
            System.out.println("Java is fun (using Boolean.TRUE)!");
        } else {
            System.out.println("Java is not fun (using Boolean.TRUE).");
        }

        Boolean anotherBooleanObject = true; // 自动装箱

        if (anotherBooleanObject == Boolean.TRUE) {
             System.out.println("Another boolean object is true!");
        } else {
             System.out.println("Another boolean object is not true.");
        }
    }
}
```
让我们看看这些改动：
- Boolean isJavaFunObject = Boolean.TRUE;：我们声明了一个 Boolean 类型的变量，并将常量 Boolean.TRUE 赋值给它。
- if (isJavaFunObject == Boolean.TRUE)：我们使用相等运算符 == 来比较 Boolean 对象和 Boolean.TRUE 常量。由于 isJavaFunObject 被赋值为 Boolean.TRUE，它们引用的是同一个对象，所以这个条件为 true。
- Boolean anotherBooleanObject = true;：这行代码展示了“自动装箱”。Java 会自动将基本数据类型 boolean 的值 true 转换为 Boolean 对象。
- if (anotherBooleanObject == Boolean.TRUE)：我们再次使用 == 来比较 anotherBooleanObject 和 Boolean.TRUE。由于自动装箱的工作方式以及 Java 对 Boolean 值的缓存机制，对于 true 和 false 这两个值，自动装箱后的 Boolean 对象通常会引用与 Boolean.TRUE 和 Boolean.FALSE 相同的缓存实例。因此，这个条件也很可能为 true。
保存文件。
编译程序：
```
javac HelloJava.java
```
运行程序：
```
java HelloJava
```
你应该会看到以下输出：
```
Java is fun (using Boolean.TRUE)!
Another boolean object is true!
```
这证实了在这些情况下，使用 == 与 Boolean.TRUE 进行比较能按预期工作，因为这些变量很可能引用的是同一个底层的 Boolean.TRUE 对象。

然而，在更复杂的场景中，依赖 == 来比较 Boolean 对象可能会有风险，特别是当 Boolean 对象以不同方式创建或来自不同来源时。一种更安全且推荐的比较 Boolean 对象值是否相等的方法是使用 .equals() 方法。

让我们修改代码以使用 .equals() 方法。

在编辑器中打开 HelloJava.java。

将 if 语句修改为使用 .equals() 方法：

public class HelloJava {
    public static void main(String[] args) {
        Boolean isJavaFunObject = Boolean.TRUE;

        if (isJavaFunObject.equals(Boolean.TRUE)) {
            System.out.println("Java is fun (using equals)!");
        } else {
            System.out.println("Java is not fun (using equals).");
        }

        Boolean anotherBooleanObject = true; // 自动装箱

        if (anotherBooleanObject.equals(Boolean.TRUE)) {
             System.out.println("Another boolean object is true (using equals)!");
        } else {
             System.out.println("Another boolean object is not true (using equals).");
        }
    }
}

我们将 == Boolean.TRUE 替换为 .equals(Boolean.TRUE)。.equals() 方法比较的是对象的值，而不是它们的内存地址。

保存文件。
编译程序：
```
javac HelloJava.java
```
运行程序：
```
java HelloJava
```
你应该会看到以下输出：
```
Java is fun (using equals)!
Another boolean object is true (using equals)!
```
使用 .equals() 方法是比较 Boolean 对象值是否相等的标准且最安全的方式。

总之，虽然由于缓存机制，== 可能适用于将 Boolean 对象与 Boolean.TRUE 进行比较，但 .equals() 方法是首选且更可靠的检查 Boolean 对象是否表示 true 值的方式。

处理空布尔值

在上一步中，我们学习了 Boolean 包装类。基本数据类型 boolean 和 Boolean 包装类的一个关键区别在于，Boolean 变量可以存储 null 值，而基本数据类型 boolean 则不能。在 Java 中，处理 null 值对于防止 NullPointerException 错误至关重要。

当你试图将一个当前指向 null 的变量当作有效对象使用时，就会发生 NullPointerException。例如，对一个 null 对象调用方法会导致 NullPointerException。

在检查一个 Boolean 对象是否为 true 时，如果该对象可能为 null，你需要格外小心。

让我们看看如果使用目前所学的方法来检查一个 null 的 Boolean 对象会发生什么。

在 WebIDE 编辑器中打开 HelloJava.java 文件。
将代码替换为以下内容：
```
public class HelloJava {
    public static void main(String[] args) {
        Boolean nullableBoolean = null;

        // 尝试使用 == 比较 null
        if (nullableBoolean == true) {
            System.out.println("This won't be printed.");
        } else {
            System.out.println("Using == with null Boolean.");
        }

        // 尝试对 null 使用 .equals() 方法
        // 这将导致一个 NullPointerException!
        // if (nullableBoolean.equals(Boolean.TRUE)) {
        //     System.out.println("This will not be reached.");
        // } else {
        //     System.out.println("This will not be reached either.");
        // }
    }
}
```
在这段代码中：
- Boolean nullableBoolean = null;：我们声明了一个 Boolean 变量，并明确将其设置为 null。
- if (nullableBoolean == true)：我们使用相等运算符 == 来比较 null 的 Boolean 对象和基本数据类型 true。当将一个 Boolean 对象（即使它为 null）与基本数据类型 boolean 进行比较时，Java 会执行“拆箱”操作。它会尝试将 Boolean 对象转换为基本数据类型 boolean。如果 Boolean 对象为 null，这个拆箱过程就会导致 NullPointerException。
- 注释掉的 .equals() 检查也会导致 NullPointerException，因为你试图对一个 null 对象（nullableBoolean）调用 .equals() 方法。
保存文件。
编译程序：
```
javac HelloJava.java
```
运行程序：
```
java HelloJava
```
你会在终端中看到一条错误消息，表明发生了 NullPointerException：
```
Exception in thread "main" java.lang.NullPointerException
    at HelloJava.main(HelloJava.java:6)
```
这表明，直接使用 == 将一个可能为 null 的 Boolean 对象与基本数据类型 boolean 进行比较，或者对其调用 .equals() 方法，都可能导致 NullPointerException。

为了安全地处理可能为 null 的 Boolean 对象，你应该在尝试对其进行拆箱或调用方法之前，先检查该对象是否为 null。

以下是如何安全地检查一个 Boolean 对象是否为 true 的方法：

在编辑器中打开 HelloJava.java。

将代码替换为以下内容：

public class HelloJava {
    public static void main(String[] args) {
        Boolean nullableBoolean = null;
        Boolean trueBoolean = Boolean.TRUE;
        Boolean falseBoolean = Boolean.FALSE;

        // 安全地检查 nullableBoolean 是否为 true
        if (nullableBoolean != null && nullableBoolean == true) {
            System.out.println("nullableBoolean is true (safe check).");
        } else {
            System.out.println("nullableBoolean is not true or is null (safe check).");
        }

        // 安全地检查 trueBoolean 是否为 true
        if (trueBoolean != null && trueBoolean == true) {
            System.out.println("trueBoolean is true (safe check).");
        } else {
            System.out.println("trueBoolean is not true or is null (safe check).");
        }

        // 安全地检查 falseBoolean 是否为 true
        if (falseBoolean != null && falseBoolean == true) {
            System.out.println("falseBoolean is true (safe check).");
        } else {
            System.out.println("falseBoolean is not true or is null (safe check).");
        }

        // 另一种使用 equals 方法的安全检查方式
        if (Boolean.TRUE.equals(nullableBoolean)) {
             System.out.println("nullableBoolean is true (safe equals check).");
        } else {
             System.out.println("nullableBoolean is not true or is null (safe equals check).");
        }

         if (Boolean.TRUE.equals(trueBoolean)) {
             System.out.println("trueBoolean is true (safe equals check).");
         } else {
             System.out.println("trueBoolean is not true or is null (safe equals check).");
         }
    }
}

在这段更新后的代码中：

if (nullableBoolean != null && nullableBoolean == true)：我们首先使用 nullableBoolean != null 检查 nullableBoolean 是否不为 null。&& 运算符表示，只有当条件的第一部分（nullableBoolean != null）为 true 时，才会计算第二部分（nullableBoolean == true）。这可以防止 NullPointerException。如果 nullableBoolean 为 null，第一部分为 false，整个条件就为 false，而不会计算第二部分。
if (Boolean.TRUE.equals(nullableBoolean))：这是另一种安全检查 Boolean 对象是否为 true 的方法，即使该对象可能为 null。通过对已知非 null 的对象 Boolean.TRUE 调用 .equals() 方法，并将可能为 null 的对象 nullableBoolean 作为参数传递，我们可以避免 NullPointerException。.equals() 方法被设计为能够优雅地处理 null 参数；Boolean.TRUE.equals(null) 会直接返回 false。

保存文件。
编译程序：
```
javac HelloJava.java
```

运行程序：

java HelloJava

你应该会看到以下输出：

nullableBoolean is not true or is null (safe check).
trueBoolean is true (safe check).
falseBoolean is not true or is null (safe check).
nullableBoolean is not true or is null (safe equals check).
trueBoolean is true (safe equals check).

这展示了如何安全地检查一个 Boolean 对象的值，即使它可能为 null，既可以使用 != null 检查结合 == true 的方式，也可以使用 Boolean.TRUE.equals() 方法。

在处理 Boolean 对象时，一定要考虑到 null 的可能性，以避免运行时错误。

总结

在本次实验中，我们学习了如何在 Java 中检查布尔变量是否为 true。我们首先使用相等运算符 == 直接将布尔变量与布尔字面量 true 进行比较。这是检查基本布尔类型值的最常见、最直接的方法。

我们还探讨了如何处理可能为 null 的 Boolean 包装类对象。我们了解到，由于对象标识的原因，使用 == 直接将 Boolean 对象与 true 进行比较可能无法达到预期效果。相反，我们应该使用 equals() 方法，或者在比较之前将 Boolean 对象拆箱为基本布尔类型值。最后，我们强调了在处理可能为 null 的 Boolean 对象时，在尝试访问其值之前检查 null 的重要性，以避免出现 NullPointerException。