本文深入探讨了java中嵌套`if`语句与使用逻辑`&&`运算符的`if`语句在行为上的细微差异，尤其是在涉及`else`子句时。尽管`if (a) { if (b) { foo(); } }`与`if (a && b) { foo(); }`在`foo()`的执行条件上等价，但当存在`else`分支时，它们的执行逻辑将因`else`所关联的条件不同而显著分化，这可能导致意料之外的程序行为。
1. 逻辑等价性：if (a) { if (b) { ... } } 与 if (a && b) { ... }
在编程实践中，开发者常常会遇到两种表达复合条件的方式：使用嵌套的if语句，或者使用逻辑&&（与）运算符将多个条件组合在一个if语句中。对于仅涉及条件为真时执行特定代码块的场景，这两种结构在语义上是等价的。
例如，以下两种结构在执行操作X方面是完全一致的：
// 结构一：嵌套if语句
if (conditionA) {
if (conditionB) {
// 执行操作X (只有当conditionA和conditionB都为真时)
System.out.println("操作X执行了 (嵌套if)");
}
}
// 结构二：使用逻辑AND运算符
if (conditionA && conditionB) {
// 执行操作X (只有当conditionA和conditionB都为真时)
System.out.println("操作X执行了 (逻辑AND)");
}这两种结构都遵循短路评估（short-circuiting）原则：如果conditionA为假，那么conditionB将不会被评估。这意味着如果conditionB包含副作用（例如，修改变量或打印输出），这些副作用将不会发生。因此，在仅关注内部代码块的执行条件时，它们确实是等价的。
2. else 子句的引入与行为分化
然而，当引入else子句时，情况变得复杂。else子句的归属不同，会导致其触发条件发生根本性变化，从而产生不同的程序行为。
立即学习“Java免费学习笔记（深入）”；
为了更好地说明这一点，我们来看一个具体的Java代码示例，该示例尝试寻找数组中的多数元素（出现次数超过 nums.length / 2 的元素）。
2.1 结构一：if (a && b) { foo(); } else { bar(); }
这种结构将else子句直接关联到整个复合条件a && b。这意味着如果a && b的整体结果为假，else分支（bar()）就会被执行。
考虑以下代码片段：
public int majorityElement(int[] nums) {
if (nums.length == 1)
return nums[0];
HashMap elements = new HashMap<>();
for (int i : nums) {
// 条件 a: elements.containsKey(i)
// 条件 b: elements.get(i) + 1 > nums.length / 2
if (elements.containsKey(i) && (elements.get(i) + 1 > nums.length / 2)) {
return i; // foo() - 找到多数元素并返回
} else {
// bar() - 更新元素计数
elements.put(i, elements.getOrDefault(i, 0) + 1);
}
}
return -999; // 未找到多数元素
} 执行分析 (nums = [2,2,1,1,1,2,2]):
- 处理第一个 2： elements.containsKey(2) 为 false。因此 if 条件整体为 false，执行 else 块。elements 更新为 {2: 1}。
- 处理第二个 2： elements.containsKey(2) 为 true。elements.get(2) 是 1。1 + 1 > 7 / 2 (即 2 > 3) 为 false。因此 if 条件整体为 false，执行 else 块。elements 更新为 {2: 2}。
- 处理第一个 1： elements.containsKey(1) 为 false。因此 if 条件整体为 false，执行 else 块。elements 更新为 {2: 2, 1: 1}。
- 处理第二个 1： elements.containsKey(1) 为 true。elements.get(1) 是 1。1 + 1 > 7 / 2 (即 2 > 3) 为 false。因此 if 条件整体为 false，执行 else 块。elements 更新为 {2: 2, 1: 2}。
- 处理第三个 1： elements.containsKey(1) 为 true。elements.get(1) 是 2。2 + 1 > 7 / 2 (即 3 > 3) 为 false。因此 if 条件整体为 false，执行 else 块。elements 更新为 {2: 2, 1: 3}。
- 处理第三个 2： elements.containsKey(2) 为 true。elements.get(2) 是 2。2 + 1 > 7 / 2 (即 3 > 3) 为 false。因此 if 条件整体为 false，执行 else 块。elements 更新为 {2: 3, 1: 3}。
- 处理第四个 2： elements.containsKey(2) 为 true。elements.get(2) 是 3。3 + 1 > 7 / 2 (即 4 > 3) 为 true。因此 if 条件整体为 true，执行 return i (即 return 2)。
此代码能够正确地找到多数元素 2。在这里，else块会在 if 条件 (a && b) 不满足时被执行，无论是因为 a 为假还是 a 为真但 b 为假。
2.2 结构二：if (a) { if (b) { foo(); } } else { bar(); }
在这种结构中，else子句仅与最外层的if (a)条件关联。这意味着bar()仅在a为假时执行。如果a为真，即使b为假，bar()也不会执行。
考虑以下代码片段：
public int majorityElement(int[] nums) {
if (nums.length == 1)
return nums[0];
HashMap elements = new HashMap<>();
for (int i : nums) {
// 条件 a: elements.containsKey(i)
if (elements.containsKey(i)) { // 外层 if (a)
// 条件 b: elements.get(i) + 1 > nums.length / 2
if (elements.get(i) + 1 > nums.length / 2) { // 内层 if (b)
return i; // foo() - 找到多数元素并返回
}
// 注意：如果 a 为真但 b 为假，这里没有任何操作
// elements.put(...) 不会在这里执行
} else { // else 关联外层 if (a)
// bar() - 仅当 a 为假时执行
elements.put(i, elements.getOrDefault(i, 0) + 1);
}
}
return -999; // 未找到多数元素
} 执行分析 (nums = [2,2,1,1,1,2,2]):
- 处理第一个 2： elements.containsKey(2) 为 false。执行 else 块。elements 更新为 {2: 1}。
-
处理第二个 2： elements.containsKey(2) 为 true。进入外层 if。
- elements.get(2) 是 1。1 + 1 > 7 / 2 (即 2 > 3) 为 false。内层 if 不执行。
- 关键点： 外层 if 的条件 elements.containsKey(2) 为 true，所以其关联的 else 块不会执行。这意味着 elements.put(i, ...) 没有被调用。elements 仍然是 {2: 1}。
- 处理第一个 1： elements.containsKey(1) 为 false。执行 else 块。elements 更新为 {2: 1, 1: 1}。
-
处理第二个 1： elements.containsKey(1) 为 true。进入外层 if。
- elements.get(1) 是 1。1 + 1 > 7 / 2 (即 2 > 3) 为 false。内层 if 不执行。
- 关键点： elements.put(i, ...) 没有被调用。elements 仍然是 {2: 1, 1: 1}。
- 后续迭代中，由于 elements 中的计数从未在条件 a 为真但 b 为假时得到更新，elements.get(i) + 1 > nums.length / 2 这个条件永远不会满足，因为 elements.get(i) 的值总是停留在 1。
- 最终，循环结束，`return -99
