逻辑运算符

逻辑运算符用于组合多个boolean条件。

逻辑运算符概述

什么是逻辑运算符

逻辑运算符连接boolean表达式，返回boolean结果。

// 逻辑运算结果
boolean result = true && false;  // false
boolean result2 = true || false;  // true
boolean result3 = !true;  // false

逻辑运算符列表

短路与 &&

短路与规则

两个条件都为true才返回true，遇false立即停止。

boolean a = true && true;   // true
boolean b = true && false;  // false
boolean c = false && true;  // false（遇false立即停止）
boolean d = false && false; // false

短路特性

int x = 5;

// 短路与：第一个为false，不执行第二个
boolean result = x < 0 && x++ > 0;
// x < 0 为false，短路，x++不执行

System.out.println(x);  // 5（未自增）

// 与逻辑与对比
int y = 5;
boolean result2 = y < 0 & y++ > 0;
// 两个都执行，y++执行

System.out.println(y);  // 6（已自增）

短路与应用

String str = null;

// 短路与避免NPE
if (str != null && str.length() > 0) {
    // str为null时，str!=null为false
    // 短路，str.length()不执行，避免NPE
    System.out.println(str);
}

// 错误顺序：会NPE
// if (str.length() > 0 && str != null) {  // NPE
// }

短路或 ||

短路或规则

任一条件为true就返回true，遇true立即停止。

boolean a = true || true;   // true（遇true停止）
boolean b = true || false;  // true（遇true停止）
boolean c = false || true;  // true
boolean d = false || false; // false

短路特性

int x = 5;

// 短路或：第一个为true，不执行第二个
boolean result = x > 0 || x++ > 0;
// x > 0 为true，短路，x++不执行

System.out.println(x);  // 5（未自增）

// 与逻辑或对比
int y = 5;
boolean result2 = y > 0 | y++ > 0;
// 两个都执行，y++执行

System.out.println(y);  // 6（已自增）

短路或应用

String str = "hello";

// 短路或简化判断
if (str == null || str.isEmpty()) {
    System.out.println("字符串无效");
}

// 性能优化：易满足条件放前面
if (quickCheck() || expensiveCheck()) {
    // quickCheck为true时，expensiveCheck不执行
}

非 !

非运算规则

取反，true变false，false变true。

boolean a = !true;   // false
boolean b = !false;  // true

// 多次取反
boolean c = !!true;  // true
boolean d = !!!true; // false

非运算应用

boolean isValid = false;

if (!isValid) {
    System.out.println("无效");
}

// 与equals配合
String str = "hello";
if (!str.equals("world")) {
    System.out.println("不是world");
}

// 判断非空
if (!list.isEmpty()) {
    System.out.println("列表不为空");
}

逻辑与 & vs 短路与 &&

区别对比

int a = 5;

// 短路与：遇false停止
boolean r1 = a < 0 && a++ > 0;  // a++不执行
// a仍为5

// 逻辑与：不短路，两个都执行
boolean r2 = a < 0 & a++ > 0;   // a++执行
// a变为6

逻辑或 | vs 短路或 ||

区别对比

| 特性 | ||（短路或） | |（逻辑或） | |------|-------------|-------------| | 结果 | 相同 | 相同 | | 短路 | 遇true停止 | 不短路 | | 效率 | 更高 | 较低 | | 推荐 | 推荐 | 不常用 |

int a = 5;

// 短路或：遇true停止
boolean r1 = a > 0 || a++ > 0;  // a++不执行
// a仍为5

// 逻辑或：不短路，两个都执行
boolean r2 = a > 0 | a++ > 0;   // a++执行
// a变为6

真值表

短路与真值表

A       B       A && B
true    true    true
true    false   false
false   true    false（短路）
false   false   false（短路）

短路或真值表

A       B       A || B
true    true    true（短路）
true    false   true（短路）
false   true    true
false   false   false

非运算真值表

A       !A
true    false
false   true

逻辑运算组合

多条件组合

int age = 25;
boolean hasLicense = true;
boolean hasInsurance = true;

// 多个条件
if (age >= 18 && hasLicense && hasInsurance) {
    System.out.println("可以开车");
}

// 任一满足
if (age < 18 || !hasLicense || !hasInsurance) {
    System.out.println("不能开车");
}

复杂条件

int score = 85;
boolean passed = true;

// 组合使用
if (score >= 60 && passed) {
    System.out.println("通过");
}

// 德摩根定律
// !(A && B) = !A || !B
// !(A || B) = !A && !B

boolean notValid = !(score >= 60 && passed);
// 等价于
boolean notValid2 = score < 60 || !passed;

运算符优先级

逻辑运算优先级

优先级（从高到低）：
1. !（非）
2. &&（短路与）
3. ||（短路或）

// 示例
boolean result = !true && false;  // false && false = false
boolean result2 = true || false && false;  // true || false = true
// &&优先级高于||，所以先算false && false = false，再true || false = true

// 使用括号明确
boolean result3 = (true || false) && false;  // true && false = false

要点总结

• &&短路与：都为true才true，遇false停止
• ||短路或：任一true就true，遇true停止
• !非：取反，true变false
• &逻辑与：不短路，两个都执行
• |逻辑或：不短路，两个都执行
• 推荐使用短路运算符（效率高）
• 短路运算符避免不必要的执行
• 常用于null检查避免NPE
• !优先级最高，&&高于||
• 复杂条件使用括号明确优先级
• 德摩根定律简化逻辑表达式