1. 算术运算符

符号	作用	说明
+	加	还可用作字符串拼接
-	减
*	乘
/	除	整数相除会舍去小数部分
%	取模 / 取余	结果符号与被除数一致
++	自增	变量 +1
--	自减	变量 -1

int a = 10;
int b = 3;

System.out.println(a + b);  // 13
System.out.println(a - b);  // 7
System.out.println(a * b);  // 30
System.out.println(a / b);  // 3: 整数除法会舍去小数部分
System.out.println(a % b);  // 1: 10 对 3 取余

// 只要有小数参与, 除法结果就是小数
System.out.println(10.0 / 3);  // 3.3333333333333335

字符串拼接：

System.out.println("Hello" + " World");    // Hello World
System.out.println("a + b = " + (a + b));  // a + b = 13

++ 和 -- 的前置后置：

int i = 10;
System.out.println(i++);  // 10: 先取 i 的原值, 再自增, i 变为 11
System.out.println(++i);  // 12: 先自增, i 变为 12, 再取新值
System.out.println(i);    // 12

2. 数据类型转换

运算时经常遇到类型不一致的情况，需要类型转换。

2.1 隐式转换（自动）

范围小 -> 范围大，系统自动完成，不需要写任何代码。

int n = 10;
double d = n;  // int 自动转成 double, d = 10.0
System.out.println(d);

注意：byte、short、char 在参与运算时，会先提升为 int 再进行运算：

byte b1 = 10;
byte b2 = 20;
// byte sum = b1 + b2;  // 报错, b1 + b2 的结果是 int
int sum = b1 + b2;      // 正确写法
System.out.println(sum);  // 30

2.2 强制转换（手动）

范围大 -> 范围小，可能丢失精度，需要手动写 (目标类型)：

double pi = 3.99;
int n = (int) pi;  // 强制转换会直接截断小数部分
System.out.println(n);  // 3: 不是四舍五入

注意：强制转换若超出目标类型范围，结果会“溢出”成很奇怪的数，务必谨慎使用。

int big = 300;
byte small = (byte) big;
System.out.println(small);   // 44: 溢出

3. 赋值运算符

符号	作用	说明
=	赋值	int a = 10; 将 10 赋给变量 a
+=	加后赋值	a += b 等价于 a = a + b
-=	减后赋值	a -= b 等价于 a = a - b
*=	乘后赋值	a *= b 等价于 a = a * b
/=	除后赋值	a /= b 等价于 a = a / b
%=	取余后赋值	a %= b 等价于 a = a % b

int a = 10;
a += 5;  // a = 15
a -= 3;  // a = 12
a *= 2;  // a = 24
a /= 4;  // a = 6
a %= 4;  // a = 2
System.out.println(a);  // 2

4. 关系运算符

符号	说明
==	判断是否等于
!=	判断是否不等于
>	大于
>=	大于等于
<	小于
<=	小于等于

关系运算的结果是 boolean 类型：

int x = 5;
int y = 8;

System.out.println(x == y);  // false
System.out.println(x != y);  // true
System.out.println(x > y);   // false
System.out.println(x < y);   // true
System.out.println(x >= 5);  // true

boolean r = x > y;           // 关系运算结果可以赋值给 boolean
System.out.println(r);       // false

注意：判断相等要写 ==，不要写成赋值 =。

5. 逻辑运算符

符号	作用	说明
&	逻辑与	两边都为真，结果才为真
|	逻辑或	只要一边为真，结果就为真
^	逻辑异或	两边不同才为真，相同为假
!	逻辑非	取反
&&	短路与	结果与 & 相同，但左边为 false 时不再判断右边
||	短路或	结果与 | 相同，但左边为 true 时不再判断右边

逻辑运算的真值表（A、B 分别代表左右两边的布尔值）：

A	B	A & B	A | B	A ^ B	!A
true	true	true	true	false	false
true	false	false	true	true	false
false	true	false	true	true	true
false	false	false	false	false	true

短路与 &&、短路或 || 的区别在于“短路”：能提前确定结果就不再执行右边。

int i = 10;
boolean ret1 = (i++ < 5) && (i++ < 20);  // 左边已为 false, 右边不再执行
System.out.println(ret1);                // false
System.out.println(i);                    // 11: 右边 ++ 没有执行

int j = 10;
boolean ret2 = (j++ > 5) || (j++ < 20);  // 左边已为 true, 右边不再执行
System.out.println(ret2);                // true
System.out.println(j);                    // 11: 右边 ++ 没有执行

6. 三元运算符

语法：数据类型 变量 = 条件 ? 值1 : 值2;

• 条件为 true，返回 值1
• 条件为 false，返回 值2
• 三元表达式的结果必须被使用：赋值、打印或返回，不能单独写在一行

int a = 10;
int b = 20;

int max = a > b ? a : b;
System.out.println(max);  // 20

System.out.println(a > b ? "a 更大" : "b 更大");  // b 更大

三元运算可以嵌套，但嵌套过深可读性差，建议用 if-else 代替：

int m = 15;
// 求三个数中的最大值
int max2 = a > b ? (a > m ? a : m) : (b > m ? b : m);
System.out.println(max2);  // 20

7. 运算符优先级

不同运算符混在一起时，先执行优先级高的。优先级从高到低（数字越小优先级越高）：

优先级	运算符 & 分隔符
1	. () {}
2	(类型) 强制转换 一元 +/- ! ~ ++ --
3	* / %
4	二元 +/-
5	<< >> >>>
6	< <= > >= instanceof
7	== !=
8	&
9	^
10	|
11	&&
12	||
13	? :
14	= += -= *= /= %= &= `

记不住优先级没关系，多用括号，可读性更强，也更不容易出错。