03. 运算符与进制详解

上篇我们把 8 种基本数据类型和变量声明搞清楚了，数据在变量里就是要拿来用的。这一篇先讲运算符——从加减乘除到自增自减，从短路逻辑到三元表达式，外加面试必考的原码反码补码。这些看似基础的东西，坑比你想的多。

一、算术运算符

先来个全家福：

1.1 整数除法的陷阱

上一篇提过，两个整数相除结果还是整数：

System.out.println(7 / 3);    // 2，不是 2.333...
System.out.println(7.0 / 3);  // 2.3333333333333335
System.out.println(7 / 3.0);  // 2.3333333333333335

只要操作数中有一个是浮点数，Java 就会自动做浮点数除法。

1.2 取模运算符 %

% 得到的是余数，用途很广：

// 判断奇偶
int num = 17;
System.out.println(num % 2 == 0 ? "偶数" : "奇数");  // 奇数

// 对负数取模的结果符号与被除数相同
System.out.println(7 % 3);   // 1
System.out.println(-7 % 3);  // -1
System.out.println(7 % -3);  // 1

🐛 面试高频：a % b 的结果符号与 a 相同。这个问题在实现循环数组、哈希表等场景会出现，有公司把它当笔试题考。

1.3 字符串拼接的 + 号

+ 在 Java 里是个”双重身份”的运算符——两边都是数字时做加法，有一边是 String 时就做拼接：

System.out.println(1 + 2 + "Java");   // "3Java"（从左到右，先算加法）
System.out.println("Java" + 1 + 2);   // "Java12"（遇到 String 后的 + 全变拼接）
System.out.println(1 + (2 + "Java")); // "12Java"（括号改变优先级）

你看出规律了吗？从左到右执行，只要遇到字符串，后面的 + 就变成了拼接符。

二、赋值运算符

最基本的 = 你已经见过了。Java 还提供了复合赋值运算符，把算术和赋值合并：

int x = 10;
x += 5;      // 相当于 x = x + 5  → 15
x -= 3;      // 相当于 x = x - 3  → 12
x *= 2;      // 相当于 x = x * 2  → 24
x /= 4;      // 相当于 x = x / 4  → 6
x %= 3;      // 相当于 x = x % 3  → 0

复合赋值不仅有写法简洁的好处，还有一个隐式的类型转换特性：

byte b = 10;
b = b + 5;     // ❌ 编译报错！b + 5 的结果是 int，不能直接赋给 byte
b += 5;        // ✅ 编译通过！复合赋值自带隐式强转（相当于 b = (byte)(b + 5)）

💡 原理：E1 op= E2 等价于 E1 = (T)((E1) op (E2))，其中 T 是 E1 的类型。所以 b += 5 会自动强转回 byte。

三、自增自减运算符

不管是写循环还是做计数，++ 和 -- 都用得极其频繁。它们的唯一作用就是让变量的值 +1 或 -1。

关键在于前置和后置的区别：

int a = 5;
int b = a++;      // 后置++：先使用 a 的当前值（5）赋值给 b，然后 a 自增为 6
System.out.println(a);  // 6
System.out.println(b);  // 5

int c = 5;
int d = ++c;      // 前置++：先将 c 自增为 6，然后把 6 赋值给 d
System.out.println(c);  // 6
System.out.println(d);  // 6

一句话口诀：“先取值后自增”（后置），”先自增后取值”（前置）。

面试里经常这样考：

int i = 0;
for (int j = 0; j < 5; j++) {
    i = i++;
}
System.out.println(i);  // 猜猜结果？

答案是 0。因为 i = i++ 的执行顺序是：先用临时变量保存 i 的值（0）→ i 自增为 1 → 再把临时变量的值（0）赋值给 i。所以循环跑完 i 还是 0。这在新手面试中是个经典陷阱，很多人想当然地认为是 5。

四、关系运算符

关系运算符用来比较两个值的大小或相等关系，结果永远是 boolean（true / false）：

int a = 10, b = 20;

System.out.println(a == b);   // false  等于
System.out.println(a != b);   // true   不等于
System.out.println(a > b);    // false  大于
System.out.println(a = b);   // false  大于等于
System.out.println(a <= b);   // true   小于等于

// 经典 bug
int x = 5;
if (x = 10) {   // ❌ 编译报错！Java 中 if 要求 boolean，而 x = 10 的结果是 int
    // ...
}

// 但如果是 boolean 类型…
boolean flag = false;
if (flag = true) {  // 🚨 不会报错！但 flag = true 是赋值表达式，结果就是 true
    // 这段代码永远会执行！这是老 C 程序员常犯的错误
}

int a = 5, b = 10;

// && 短路：左边为 false，右边不执行
boolean result1 = (a > 10) && (b++ > 0);
System.out.println(b);      // 10（b++ 没被执行！）

// || 短路：左边为 true，右边不执行
boolean result2 = (a  0);
System.out.println(b);      // 10（b++ 仍然没被执行）

int i = 0, j = 0;
boolean r = (i++ > 0) && (j++ > 0);
System.out.println(i + ", " + j);  // 猜猜？ → 1, 0

// i++ > 0 → 0 > 0 → false，i 变成 1
// 因为 && 短路，j++ 没被执行，j 仍然是 0

int a = 5, b = 10;

boolean r1 = (a > 10) & (b++ > 0);  // & 不短路，两边都算
System.out.println(b);              // 11（b++ 执行了）

boolean r2 = (a > 10) && (b++ > 0); // && 短路，右边不算
System.out.println(b);              // 11（没再自增）

类型 变量 = (条件表达式) ? 值1 : 值2;

int age = 18;
String result = (age >= 18) ? "成年人" : "未成年人";
System.out.println(result);  // 成年人

// 三元运算符可以嵌套，但不建议—可读性太差
int score = 85;
String grade = score >= 90 ? "优秀"
              : score >= 80 ? "良好"
              : score >= 60 ? "及格"
              : "不及格";
System.out.println(grade);   // 良好

  5 的补码：0000 0101
 -3 的补码：1111 1101（3 → 0000 0011 → 取反 1111 1100 → +1 → 1111 1101）
  ────────────
  结果：    1 0000 0010

  高位溢出丢弃，得到 0000 0010 = 2 ✅

// 常用技巧：用 & 判断奇偶（效率比 % 高一点点）
int num = 7;
System.out.println((num & 1) == 0 ? "偶数" : "奇数");  // 奇数

// 异或的小特性：a ^ b ^ b = a（同数异或两次恢复原值）
int cipher = 42;
int key = 99;
int encrypted = cipher ^ key;   // 加密
int decrypted = encrypted ^ key; // 解密：42
System.out.println(decrypted);  // 42