一、核心概念

Boolean 是 Java 中的包装类（Wrapper Class），位于 java.lang.Boolean 包中，用于封装基本数据类型 boolean 的值（true 或 false）。

1.1 基本信息

属性 说明
类型 包装类（Wrapper）
所属包 java.lang.Boolean（无需导入）
继承 Object → Boolean
实现接口 Comparable<Boolean>
封装类型 boolean（基本类型）
默认值 null（引用类型）

1.2 两种创建方式

  • 基本类型：boolean flag = true;
  • 包装类型：Boolean flag = true;（自动装箱）

1.3 自动装箱与拆箱（Autoboxing / Unboxing）

Java 5 引入特性，允许自动在 boolean 与 Boolean 之间转换：

Boolean b1 = true;        // 自动装箱
boolean b2 = b1;          // 自动拆箱

⚠️ 注意：null 的 Boolean 拆箱会抛出 NullPointerException

二、操作步骤（超详细）

步骤 1：声明与初始化

// 方式1：直接赋值（推荐）
Boolean flag1 = true;
Boolean flag2 = false;

// 方式2：使用构造函数（已废弃，不推荐）
Boolean flag3 = new Boolean(true);     // 已过时（deprecated）
Boolean flag4 = new Boolean("true");   // 字符串构造，不推荐

// 方式3：静态工厂方法（推荐）
Boolean flag5 = Boolean.valueOf(true);
Boolean flag6 = Boolean.valueOf("true"); // 字符串转 Boolean

✅ 推荐使用 Boolean.valueOf()，因为它可以缓存常用值，提升性能。

步骤 2：字符串转 Boolean

String str = "True";

// 方法1：Boolean.valueOf（推荐）
Boolean b1 = Boolean.valueOf(str); // 忽略大小写，"true" 返回 true，其他返回 false

// 方法2：new Boolean（不推荐）
Boolean b2 = new Boolean(str);     // 同上，但不缓存，性能差

System.out.println(b1); // true
System.out.println(Boolean.valueOf("yes")); // false
System.out.println(Boolean.valueOf("1"));   // false

🔍 注意：只有字符串 "true"（忽略大小写）会被识别为 true，其余一律为 false。

步骤 3：比较 Boolean 值

Boolean b1 = true;
Boolean b2 = Boolean.valueOf("True");
Boolean b3 = null;

// 正确方式：使用 equals()
if (b1.equals(b2)) {
    System.out.println("b1 equals b2");
}

// 错误方式：使用 ==（可能出错，因为涉及对象引用）
if (b1 == b2) { ... } // ❌ 不推荐，除非确定是同一对象

// 安全比较（处理 null）
Boolean.compare(b1, b2); // 返回 int：0 相等，1/-1 不等

✅ 推荐使用 equals() 或 Boolean.compare()。

步骤 4：转换为基本类型

Boolean b = true;
boolean primitive = b.booleanValue(); // 拆箱

// 或直接赋值（自动拆箱）
boolean p2 = b;

⚠️ 如果 b == null，booleanValue() 会抛出 NullPointerException

步骤 5：条件判断中的使用

Boolean flag = getFlag(); // 可能返回 null

// 安全写法
if (Boolean.TRUE.equals(flag)) {
    // 安全，即使 flag 为 null 也不会报错
}

// 危险写法
if (flag == true) { ... } // ❌ 可能空指针
if (flag) { ... }         // ❌ 编译错误，flag 是引用类型

✅ 推荐使用 Boolean.TRUE.equals(flag) 避免空指针。

三、常见错误

错误 说明 修复方式
NullPointerException 对 null 的 Boolean 调用 .booleanValue() 或 if (flag) 使用 equals() 或判空
使用 == 比较对象 Boolean b1 = true; Boolean b2 = true; b1 == b2 可能为 false（JVM 缓存机制不稳定） 使用 .equals()
误以为 "yes" 是 true Boolean.valueOf("yes") 返回 false 明确只接受 "true" 字符串
使用构造函数 new Boolean(...) 已废弃，不缓存，性能差 改用 Boolean.valueOf()

四、注意事项

  1. Boolean 是引用类型，可以为 null，而 boolean 不能。
  2. 自动拆箱风险：null 拆箱会抛出 NullPointerException。
  3. 字符串解析严格：只有 "true"（忽略大小写）为 true，其他如 "on", "1", "yes" 都是 false。
  4. 缓存机制：Boolean.valueOf() 缓存了 TRUE 和 FALSE 两个实例，节省内存。
  5. 线程安全：Boolean 对象是不可变的（immutable），线程安全。

五、使用技巧

5.1 安全判空比较

public static boolean isTrue(Boolean flag) {
    return Boolean.TRUE.equals(flag);
}

public static boolean isFalse(Boolean flag) {
    return Boolean.FALSE.equals(flag);
}

5.2 默认值处理

Boolean input = getUserInput(); // 可能 null
boolean result = Boolean.TRUE.equals(input); // 默认 false
// 或
boolean result2 = input != null && input; // 显式判空

5.3 使用 Optional（Java 8+）

Optional<Boolean> opt = Optional.ofNullable(flag);
opt.ifPresent(b -> System.out.println("Flag is " + b));

六、最佳实践

实践 说明
✅ 使用 Boolean.valueOf() 创建实例 性能更好，利用缓存
✅ 使用 .equals() 比较 安全、正确
✅ 避免 null 拆箱 使用 equals 或判空
✅ 优先使用 boolean 而非 Boolean 除非需要 null 状态（如数据库映射）
✅ 明确字符串解析规则 不要依赖 "1" 或 "yes" 转 true

七、性能优化

  1. 使用 valueOf() 而非 new Boolean()
    valueOf() 返回缓存实例，减少对象创建。

  2. 避免频繁装箱拆箱
    在循环中尽量使用 boolean 而非 Boolean：

    // 慢
for (int i = 0; i < 10000; i++) {
    Boolean b = i % 2 == 0;
    // ...
}

// 快
for (int i = 0; i < 10000; i++) {
    boolean b = i % 2 == 0;
    // ...
}

  3. 缓存常用 Boolean 对象
    Boolean.TRUE 和 Boolean.FALSE 是常量，可直接使用：

    return someCondition ? Boolean.TRUE : Boolean.FALSE;

八、总结：Boolean 使用口诀

🔤 “值用 boolean，对象用 valueOf，比较用 equals，判空要小心”

九、附录：常用方法一览

方法 说明
Boolean.valueOf(boolean) 创建 Boolean 实例（推荐）
Boolean.valueOf(String) 字符串转 Boolean
booleanValue() 转为基本 boolean
equals(Object) 比较是否相等
compareTo(Boolean) 比较（用于排序）
toString() 返回 "true" 或 "false"
parseBoolean(String) 静态方法，返回 boolean 类型