java Boolean.logicalXor对两个 `boolean` 值执行逻辑异或（XOR）运算

方法定义

public static boolean logicalXor(boolean a, boolean b)

所属类：java.lang.Boolean
返回类型：boolean（基本类型）
访问修饰符：public static
参数：
- a：第一个布尔值
- b：第二个布尔值
功能：对两个 boolean 值执行逻辑异或（XOR） 运算，并返回结果。

✅ 从 Java 8 开始引入。

功能说明

逻辑异或（XOR） 的规则是：

当且仅当两个操作数不同时，结果为 true；相同时为 false。

a	b	a XOR b
`false`	`false`	`false`
`false`	`true`	`true`
`true`	`false`	`true`
`true`	`true`	`false`

即：相同为假，不同为真

Boolean.logicalXor(a, b) 等价于：

a ^ b           // 使用位运算符 ^
a != b          // 布尔值比较是否不等

示例代码

1. 基本用法

boolean result1 = Boolean.logicalXor(true, false);
System.out.println(result1); // 输出: true

boolean result2 = Boolean.logicalXor(false, false);
System.out.println(result2); // 输出: false

boolean result3 = Boolean.logicalXor(true, true);
System.out.println(result3); // 输出: false

2. 与直接运算符对比

boolean a = true;
boolean b = false;

System.out.println(Boolean.logicalXor(a, b)); // true
System.out.println(a ^ b);                    // true（等价）
System.out.println(a != b);                   // true（等价）

3. 实际应用场景：状态切换判断

// 判断用户是否改变了“启用”状态
boolean oldEnabled = true;
boolean newEnabled = false;

if (Boolean.logicalXor(oldEnabled, newEnabled)) {
    System.out.println("状态已改变（开启 ↔ 关闭）");
} else {
    System.out.println("状态未变");
}
// 输出: 状态已改变（开启 ↔ 关闭）

4. 用于奇偶校验或标志位翻转逻辑

// 模拟开关翻转：每按一次，状态翻转
boolean currentState = false;
boolean togglePressed = true;

// 只有在按钮被按下时才翻转状态
boolean newState = Boolean.logicalXor(currentState, togglePressed);
System.out.println(newState); // 输出: true（翻转）

使用技巧

✅ 1. 提高代码可读性

相比 a ^ b 或 a != b，logicalXor 更明确表达“异或”意图，尤其在复杂逻辑中：

// 更清晰
if (Boolean.logicalXor(hasPermission, isAdmin)) { ... }

// 需要思考
if (hasPermission ^ isAdmin) { ... }

✅ 2. 与包装类统一风格

在大量使用 Boolean.TRUE、Boolean.valueOf() 等静态方法的代码中，使用 logicalXor 保持风格一致。

✅ 3. 作为函数式编程中的方法引用

BinaryOperator<Boolean> xorOp = Boolean::logicalXor;

List<Boolean> results = Stream.of(
    xorOp.apply(true, false),
    xorOp.apply(false, true)
).collect(Collectors.toList());

常见错误

❌ 1. 误用于对象（`Boolean`）而非基本类型

Boolean a = Boolean.TRUE;
Boolean b = Boolean.FALSE;

// 错误：参数是 Boolean 对象，但方法要求 boolean
// boolean result = Boolean.logicalXor(a, b); // 编译错误或自动拆箱

// 正确：自动拆箱或显式调用
boolean result = Boolean.logicalXor(a, b); // ✅ 可行（自动拆箱）
// 或
boolean result2 = Boolean.logicalXor(a.booleanValue(), b.booleanValue());

❌ 2. 误解异或逻辑

误以为 XOR 是“至少一个为真”（那是 OR），而 XOR 要求“恰好一个为真”。

注意事项

项目	说明
🆕 Java 8+	该方法在 Java 8 中新增，旧版本不支持
🔢 参数是基本类型	接收 `boolean`，不是 `Boolean` 对象（但支持自动拆箱）
⚠️ 无空指针风险	因为参数是 `boolean` 基本类型，不会为 `null`
💡 静态工具方法	属于工具类用法，无需实例化
📏 性能	与 `a ^ b` 几乎无差别，JVM 会优化

最佳实践

场景	推荐做法
简单异或运算	`a ^ b` 或 `a != b`（性能最佳）
强调语义清晰	`Boolean.logicalXor(a, b)`
函数式编程	使用方法引用 `Boolean::logicalXor`
条件判断	直接使用表达式，无需封装

性能优化

✅ logicalXor(a, b) 内部实现非常简单，通常被 JVM 内联优化。
✅ 与直接使用 ^ 运算符性能几乎一致。
⚠️ 在极高频循环中，可直接使用 a ^ b，但差异微乎其微。

源码实现（Java 8+）：

public static boolean logicalXor(boolean a, boolean b) {
    return a ^ b;
}

与其他布尔运算对比

方法	等价表达式	说明
`Boolean.logicalAnd(a, b)`	`a && b`	逻辑与
`Boolean.logicalOr(a, b)`	`a \\|\\| b`	逻辑或
`Boolean.logicalXor(a, b)`	`a ^ b` 或 `a != b`	逻辑异或
`!a`	`Boolean.logicalNot(a)`（无此方法）	逻辑非需用 `!`

注意：Java 没有 logicalNot(boolean)，取反仍用 !a。

总结

要点	说明
核心功能	执行两个布尔值的逻辑异或（XOR）运算
等价操作	`a ^ b` 或 `a != b`
适用版本	Java 8 及以上
主要优势	提升代码可读性，明确表达“异或”意图
性能表现	与 `^` 运算符几乎无差异
最佳实践	在需要强调逻辑语义时使用，否则可用 `^` 或 `!=`

✅ 一句话掌握：
Boolean.logicalXor(a, b) 是 Java 8 提供的语义更清晰的异或运算工具方法，等价于 a ^ b，适用于强调逻辑意图的场景，但在性能敏感代码中可直接使用 ^。它是 logicalAnd 和 logicalOr 的补充，完善了布尔逻辑工具集。