1. Java运算符基础概述
刚接触Java编程时，运算符就像是我们与计算机对话的基本词汇。它们决定了数据如何被处理、比较和操作。作为Java基础语法中最核心的组成部分之一，运算符贯穿了我们整个编程生涯。
Java中的运算符主要分为以下几大类：算术运算符、关系运算符、逻辑运算符、位运算符、赋值运算符以及其他特殊运算符。每种运算符都有其特定的使用场景和运算规则。理解它们的优先级和结合性尤为重要，这直接影响到表达式的求值顺序和最终结果。
在实际开发中，运算符的误用是新手常犯的错误之一。比如把赋值运算符"="与相等运算符"=="混淆，或者在复合赋值时忽略类型转换问题。这些问题看似简单，却可能导致程序逻辑出现严重错误。
提示：运算符优先级记忆技巧 - 可以记住口诀"单算移关与，异或逻条赋"，分别对应：单目运算符→算术运算符→移位运算符→关系运算符→按位与→按位异或→按位或→逻辑与→逻辑或→条件运算符→赋值运算符。
2. 算术运算符详解
2.1 基本算术运算
Java提供了标准的四则运算运算符：
- 加法(+)
- 减法(-)
- 乘法(*)
- 除法(/)
- 取模(%)
这些运算符的使用看似简单，但有几个关键点需要注意：
java复制int a = 10;
int b = 3;
System.out.println(a / b); // 输出3而非3.333...，整数除法会截断小数部分
System.out.println((double)a / b); // 输出3.333...，需显式类型转换
int c = -10;
System.out.println(c % 3); // 输出-1，取模运算结果符号与被除数一致
2.2 自增自减运算符
++和--运算符有前缀和后缀两种形式，它们的区别在于表达式求值的时机：
java复制int x = 5;
int y = x++; // y=5，x=6（后缀：先赋值后自增）
int z = ++x; // z=7，x=7（前缀：先自增后赋值）
在实际项目中，我建议避免在复杂表达式中混合使用自增/自减运算符，这会导致代码可读性下降且容易出错。比如：
java复制int i = 0;
i = i++ + ++i; // 这种写法虽然合法但难以理解
2.3 复合赋值运算符
Java提供了+=、-=、*=等复合赋值运算符，它们不仅简化了代码，还隐含了类型转换：
java复制short s = 5;
s = s + 2; // 编译错误，需要强制类型转换
s += 2; // 正确，复合赋值隐含类型转换
需要注意的是，复合赋值运算符会隐含执行类型转换，这可能导致精度损失：
java复制int num = 1000000;
short snum = 0;
snum += num; // 编译通过但结果不正确
3. 关系与逻辑运算符
3.1 关系运算符
关系运算符用于比较两个值，返回boolean结果：
- 等于(==)
- 不等于(!=)
- 大于(>)
- 小于(<)
- 大于等于(>=)
- 小于等于(<=)
常见陷阱是比较对象引用而非内容：
java复制String s1 = new String("hello");
String s2 = new String("hello");
System.out.println(s1 == s2); // false，比较的是引用
System.out.println(s1.equals(s2)); // true，比较内容
3.2 逻辑运算符
逻辑运算符用于组合多个boolean表达式：
- 逻辑与(&&)
- 逻辑或(||)
- 逻辑非(!)
&&和||具有短路特性，这在某些场景下非常有用：
java复制if (obj != null && obj.method()) {
// 如果obj为null，不会执行obj.method()
}
注意：&和|也可以用于逻辑运算，但它们不会短路，总是会计算所有操作数。
4. 位运算符与移位运算符
4.1 位运算符
位运算符直接操作整数的二进制位：
- 按位与(&)
- 按位或(|)
- 按位异或(^)
- 按位取反(~)
一个实用技巧是使用位运算进行标志位管理：
java复制final int FLAG_A = 1 << 0; // 0001
final int FLAG_B = 1 << 1; // 0010
final int FLAG_C = 1 << 2; // 0100
int flags = FLAG_A | FLAG_C; // 0101
// 检查标志位
if ((flags & FLAG_A) != 0) {
System.out.println("Flag A is set");
}
4.2 移位运算符
移位运算符用于对二进制位进行移动：
- 左移(<<)
- 右移(>>)
- 无符号右移(>>>)
移位运算常用于高效实现乘除法：
java复制int n = 8;
int doubled = n << 1; // 16，相当于*2
int halved = n >> 1; // 4，相当于/2
需要注意的是，右移运算符(>>)会保留符号位，而>>>会用0填充高位：
java复制int negative = -8;
System.out.println(negative >> 1); // -4
System.out.println(negative >>> 1); // 2147483644
5. 条件运算符与赋值运算符
5.1 条件运算符(?:)
条件运算符是Java中唯一的三元运算符，语法为：
条件 ? 表达式1 : 表达式2
它可以简化简单的if-else结构：
java复制int max = (a > b) ? a : b;
但过度使用会降低代码可读性：
java复制// 不推荐的写法
String result = condition1 ? value1 : condition2 ? value2 : condition3 ? value3 : defaultValue;
5.2 赋值运算符
基本的赋值运算符(=)将右侧的值赋给左侧变量。Java还支持多重赋值：
java复制int x, y, z;
x = y = z = 10; // 所有变量都赋值为10
但要注意赋值表达式的值就是被赋的值：
java复制int a;
int b = (a = 5) * 2; // b=10
6. 运算符优先级与结合性
运算符优先级决定了表达式中运算的执行顺序。当优先级相同时，结合性决定了运算方向（从左到右或从右到左）。
常见运算符优先级从高到低：
- 括号()、[]、.
- 单目运算符：++、--、!、~
- 乘除取模：*、/、%
- 加减：+、-
- 移位：<<、>>、>>>
- 关系：<、<=、>、>=
- 相等：==、!=
- 位与：&
- 位异或：^
- 位或：|
- 逻辑与：&&
- 逻辑或：||
- 条件：?:
- 赋值：=、+=、-=等
当不确定优先级时，使用括号是最安全的做法：
java复制// 难以理解的表达式
int result = a + b * c << 2 & 0xFF;
// 使用括号明确优先级
int result = ((a + (b * c)) << 2) & 0xFF;
7. 常见问题与实用技巧
7.1 浮点数比较问题
由于浮点数的精度问题，直接使用==比较可能会出错：
java复制double d1 = 0.1 + 0.2;
double d2 = 0.3;
System.out.println(d1 == d2); // false
// 正确的比较方式
final double EPSILON = 1e-10;
System.out.println(Math.abs(d1 - d2) < EPSILON); // true
7.2 字符串连接运算符
+运算符在字符串上下文中有特殊行为：
java复制System.out.println(1 + 2 + "3"); // "33"
System.out.println("1" + 2 + 3); // "123"
System.out.println(1 + "2" + 3); // "123"
7.3 运算符重载的限制
与C++不同，Java不支持自定义运算符重载，除了+可以用于字符串连接：
java复制// 这是Java内置的唯一运算符重载
String s = "Hello" + " " + "World";
7.4 类型提升规则
当操作数类型不同时，Java会自动进行类型提升：
java复制byte b = 10;
short s = 20;
int result = b + s; // byte和short运算前会提升为int
7.5 位运算优化技巧
位运算在某些场景下可以替代算术运算，提高性能：
java复制// 判断奇偶
boolean isOdd = (num & 1) != 0;
// 交换两个变量的值
a ^= b;
b ^= a;
a ^= b;
// 取绝对值（32位整数）
int abs = (n ^ (n >> 31)) - (n >> 31);
8. 面试常见问题解析
8.1 ==与equals的区别
这是Java面试中最常见的问题之一：
- ==比较基本类型的值或对象的引用
- equals方法比较对象的内容（需要正确重写）
java复制Integer i1 = 127;
Integer i2 = 127;
System.out.println(i1 == i2); // true，因为-128到127有缓存
Integer i3 = 128;
Integer i4 = 128;
System.out.println(i3 == i4); // false，超出缓存范围
8.2 短路逻辑运算的应用
利用短路特性可以避免空指针异常：
java复制if (list != null && !list.isEmpty()) {
// 安全访问list
}
8.3 复合赋值的类型转换
复合赋值运算符隐含的类型转换可能导致意外结果：
java复制byte b = 10;
b = b + 1; // 编译错误
b += 1; // 正确，相当于 b = (byte)(b + 1)
8.4 移位运算与乘除法的性能
在现代JVM中，简单的乘除法通常会被优化为移位运算，因此手动优化往往没有必要：
java复制// 不需要这样写
int n = x << 1;
// 直接写更清晰
int n = x * 2;
8.5 运算符优先级陷阱
一些常见的优先级陷阱：
java复制int mask = 0xFF;
int value = 0x42;
boolean result = value & mask == mask; // 错误，相当于value & (mask == mask)
boolean correct = (value & mask) == mask;
9. 实际项目中的应用建议
9.1 代码可读性优先
虽然某些运算符技巧可以简化代码，但可读性应该放在首位：
java复制// 不推荐
flag ^= true;
// 推荐
flag = !flag;
9.2 避免过度复杂的表达式
将复杂表达式拆分为多个步骤：
java复制// 难以理解
int result = (a > b) ? (c < d ? e : f) : (g != h ? i : j);
// 更清晰
int result;
if (a > b) {
result = (c < d) ? e : f;
} else {
result = (g != h) ? i : j;
}
9.3 注意数值运算的边界情况
特别是整数溢出问题：
java复制int max = Integer.MAX_VALUE;
int overflow = max + 1; // 变成Integer.MIN_VALUE
9.4 使用括号明确意图
即使知道优先级规则，使用括号也能使代码更清晰：
java复制// 虽然正确但不够清晰
if (a & b == c | d)
// 更清晰
if ((a & (b == c)) | d)
9.5 运算符的性能考量
在大多数情况下，运算符的性能差异可以忽略不计。只有在真正需要优化的热点代码中才应考虑微优化：
java复制// 不需要过早优化
for (int i = 0; i < array.length; i++) {
// 使用array[i]而不是预先保存length
}
在实际开发中，我经常遇到开发者在应该使用equals的地方误用==，或者在处理浮点数时直接比较相等。这些看似简单的错误可能导致难以发现的bug。最好的实践是理解每种运算符的精确语义，并在不确定时查阅文档或编写测试用例验证行为。