Java 运算符详解：算术、逻辑、位运算及优先级

int / int 结果仍为 int，向下取整（舍弃小数点后所有数）：

int a = 3;
int b = 2;
System.out.println(a / b); // 1（非 1.5）
// 想得到数学精确结果，需将其中一个数转为浮点型
double d = a * 1.0 / b;
System.out.println(d); // 1.5

2. 增量运算符：+= -= *= /= %=

特点：运算结果自动赋值给左操作数，仅支持变量，不支持常量；可帮你进行类型转换。 代码案例：

int a = 1;
a += 2; // 等价于 a = a + 2 → a=3
System.out.println(a);
a -= 1; // 等价于 a = a - 1 → a=2
System.out.println(a);
a *= 3; // 等价于 a = a * 3 → a=6
System.out.println(a);
a /= 3; // 等价于 a = a / 3 → a=2
System.out.println(a);
a %= 3; // 等价于 a = a % 3 → a=2
System.out.println(a);
int c = 10;
long d = 20;
c += d;
System.out.println(c); // 30

3. 自增/自减运算符：++ --

作用：++ 给变量 +1，-- 给变量 -1；仅支持变量，不支持常量。 核心区别：单独使用无区别，混合使用有先后顺序。 代码案例：

int a = 1;
a++; // 后置 ++，单独使用 → a=2
++a; // 前置 ++，单独使用 → a=3
// 混合使用：后置 ++ 先使用原值，表达式结束后 +1
System.out.println(a++); // 输出 3，执行后 a=4
// 混合使用：前置 ++ 先 +1，再使用新值
System.out.println(++a); // 先 a=5，再输出 5
// 自减 -- 规则与自增 ++ 完全一致
a--;
System.out.println(a--); // 输出 4，执行后 a=3
--a;
System.out.println(--a); // 先 a=1，再输出 1

三、关系运算符

常用符号：== != < > <= >=（共 6 个） 核心特点：运算结果为布尔值（true/false）；= 是赋值，== 才是判断相等。 代码案例：

int a = 10;
int b = 20;
System.out.println(a == b); // false
System.out.println(a != b); // true
System.out.println(a < b); // true
System.out.println(a > b); // false
System.out.println(a <= b); // true
System.out.println(a >= b); // false

关键注意：不能连续写多个关系运算符（与数学不同），如 3 < a < 5 是错误写法。

四、逻辑运算符（重点）

常用符号：&& || !（逻辑与、逻辑或、逻辑非） 核心特点：操作数为布尔值，运算结果也为布尔值；&& 和 || 支持短路求值。

1. 逻辑与 &&：一假则假，全真才真

规则：左右表达式都为 true，结果才为 true；任意一个为 false，结果为 false。 代码案例：

int a = 1;
int b = 2;
System.out.println(a == 1 && b == 2); // true（全真）
System.out.println(a == 1 && b > 100); // false（右假）
System.out.println(a > 100 && b == 2); // false（左假）
System.out.println(a > 100 && b > 100); // false（全假）

2. 逻辑或 ||：一真则真，全假才假

规则：左右表达式任意一个为 true，结果为 true；都为 false 时，结果为 false。 代码案例：

int a = 1;
int b = 2;
System.out.println(a == 1 || b == 2); // true（全真）
System.out.println(a == 1 || b > 100); // true（左真）
System.out.println(a > 100 || b == 2); // true（右真）
System.out.println(a > 100 || b > 100); // false（全假）

3. 逻辑非 !：真变假，假变真

规则：一元运算符，仅对一个布尔表达式取反。 代码案例：

int a = 1;
System.out.println(!(a == 1)); // false（原 true 取反）
System.out.println(!(a != 1)); // true（原 false 取反）

4. 短路求值（核心特性）

规则：&& 左侧为 false 时，直接返回 false，不计算右侧表达式；|| 左侧为 true 时，直接返回 true，不计算右侧表达式。 代码案例（无异常，因右侧未执行）：

// 10/0 会抛异常，但此处因短路求值未执行
System.out.println(10 > 20 && 10 / 0 == 0); // false
System.out.println(10 < 20 || 10 / 0 == 0); // true

对比：& 和 | 作逻辑运算时不支持短路求值，会执行所有表达式，直接抛异常：

System.out.println(10 > 20 & 10 / 0 == 0); // 报错
System.out.println(10 < 20 | 10 / 0 == 0); // 报错

五、位运算符

Java 中数据操作最小单位是比特位（0/1），位运算符按二进制位逐位运算； 常用符号：& | ~ ^（按位与、按位或、按位取反、按位异或）；除 ~ 是一元运算符，其余为二元。 注意：操作数为整数时是位运算，为布尔值时是逻辑运算（与 && || 区分）。

1. 按位与 &：两位都为 1，结果为 1，否则为 0

代码案例：

int a = 10; // 二进制：00001010
int b = 20; // 二进制：00010100
System.out.println(a & b); // 0（二进制：00000000）
System.out.println(10 < 20 & 10 > 0); // 都为真，true
System.out.println(10 > 20 & 10 > 0); // 第一个为假，false
System.out.println(10 < 20 & 10 < 0); // 第二个为假。false
System.out.println(10 > 20 & 10 < 0); // 都为假，false

2. 按位或 |：两位都为 0，结果为 0，否则为 1

代码案例：

int a = 10; // 二进制：00001010
int b = 20; // 二进制：00010100
System.out.println(a | b); // 30（二进制：00011110）

3. 按位取反 ~：0 变 1，1 变 0

代码案例（十六进制简化二进制，%x 按十六进制输出）：

int a = 0xf; // 0xf=15，二进制：00001111
System.out.printf("%x\n", ~a); // 按位取反后结果：ffffff0

4. 按位异或 ^：两位相同为 0，不同为 1

核心特性：两个相同数异或结果为 0； 代码案例：

int a = 0x1; // 二进制：0001
int b = 0x2; // 二进制：0010
System.out.printf("%x\n", a ^ b); // 3（二进制：0011）
System.out.println(5 ^ 5); // 0（相同数异或为 0）
System.out.println(5 ^ 0); // 5（0 异或任何数为当前那个数）

六、移位运算符（了解）

按二进制比特位移动，都是二元运算符；符号：<< >> >>>（左移、右移、无符号右移）。

1. 左移 <<：最左侧位舍弃，最右侧补 0

规则：左移 N 位 ≈ 原数 × 2 的 N 次方（计算效率高于乘除）； 代码案例（0x10 是十六进制，对应十进制 16）：

int a = 0x10;
System.out.printf("%x\n", a << 1); // 20（左移 1 位，16×2=32=0x20）

注意：左移会舍弃符号位，正数左移可能变成负数。

2. 右移 >>：最右侧位舍弃，最左侧补符号位（正数 (符号位为 0) 补 0，负数 (符号位为 1) 补 1）

规则：右移 N 位 ≈ 原数 ÷ 2 的 N 次方； 代码案例：

int a = 0x10;
System.out.printf("%x\n", a >> 1); // 8（16÷2=8=0x8）
int b = 0xffff0000; // 负数
System.out.printf("%x\n", b >> 1); // ffff8000（左侧补 1）
int c = -1;
System.out.println(c >> 2); // -1

3. 无符号右移 >>>：最右侧位舍弃，最左侧统一补 0（无论正负）

代码案例：

int a = 0xffffffff; // 负数
System.out.printf("%x\n", a >>> 1); // 7fffffff（左侧补 0）

移位通用注意：

1. 移位效率远高于乘除，乘除 2 的 N 次方时优先用移位；
2. 移动负数位、移位位数过大，均无实际意义。

七、条件运算符

唯一符号：表达式 1 ? 表达式 2 : 表达式 3（Java 唯一三目运算符）； 作用：简化条件判断，是 if-else 的简写形式。 执行规则：

• 表达式 1 为 true → 整个表达式结果=表达式 2 的值；
• 表达式 1 为 false → 整个表达式结果=表达式 3 的值。

代码案例

// 求两个整数的最大值
int a = 10;
int b = 20;
int max = a > b ? a : b;
System.out.println(max); // 20
//强化 boolean flg = true == true ? true == false ? false : true : false;
System.out.println(flg); // true

核心注意事项

条件表达式不能单独存在，运算结果必须被使用（赋值/输出等）：

int a = 10;
int b = 20;
a > b ? a : b; // 报错：不是有效语句

表达式 2 和表达式 3 的结果类型必须一致（除非支持隐式类型转换）：

int a = 10;
int b = 20;
int c = a > b ? 1 : 2.0; // 错误：类型不匹配（int 和 double）

八、运算符的优先级

1. 不同运算符优先级不同（如 * / 高于 + -，+ - 高于移位运算符）；
2. 无需记忆优先级规则，加括号即可消除表达式歧义，提升代码可读性。

代码案例

// 求 a 和 b 的平均值，错误写法（+ 优先级高于>>）
int a = 10;
int b = 20;
int c = a + (b - a) >> 1; // 等价于 (10+10)>>1 → 20>>1=10
System.out.println(c); // 10
// 正确写法：加括号明确运算顺序
int d = a + ((b - a) >> 1);
System.out.println(d); // 15