吊打面试官(四)--Java语法基础运算符一文全掌握
简介
本文介绍了Java运算符相关知识，包含运算规则，运算符使用经验，特殊运算符注意事项等，全文5400字。熟悉了这些内容，在运算符这块就可以吊打面试官了。
Java运算符的规则与特性
1. 贪心规则（Maximal Munch Rule）
贪心规则是指编译器在解析表达式时，会尽可能多地匹配字符，以形成最长的有效运算符或符号。编译器不会跳过空格合并，因此可以使用空格进行识别。
- **代码示例**：
```java
int a = 10; int b = a+++a; // 解析为 (a++) + a
```代码解释如下：
- 编译器会尽可能多地匹配运算符，因此 `a+++a` 被解析为 `(a++) + a`，而不是 `a + (++a)`。
- 最终结果是 `10 + 11 = 21`。
如何避免语句有歧义？：
1. **使用括号**：明确表达式的优先级，使用（）表示优先。
```java int c = (a++) + b; ```
2. **添加空格**：编译器不会跳过空格合并，可以明确分隔运算符。
```java int c = a + ++b; ```
3. **拆分表达式**：将复杂的表达式拆分为多个简单的表达式，避免歧义。
```java int temp = a++; int c = temp + b; ```
2. 运算符优先级（Precedence）
运算符优先级决定了表达式中运算符的执行顺序。优先级高的运算符会先被计算。
- **常见运算符优先级（从高到低）**：
1. `()`（括号）
2. `++`、`--`（后缀递增/递减）、`+`、`-`（一元正负）、`!`、`~`（按位取反）
3. `*`、`/`、`%`（乘法、除法、取模）
4. `+`、`-`（加法、减法）
5. `<<`、`>>`、`>>>`（位移）
6. `<`、`<=`、`>`、`>=`、`instanceof`（比较）
7. `==`、`!=`（相等性比较）
8. `&`（按位与）
9. `^`（按位异或）
10. `|`（按位或）
11. `&&`（逻辑与）
12. `||`（逻辑或）
13. `?:`（三元运算符）
14. `=`、`+=`、`-=`、`*=`、`/=`、`%=`（赋值运算符）
- **示例**：
```java int result = 5 + 3 * 2;
// 3 * 2 先计算，结果是 5 + 6 = 11 ```
3. 运算符结合性（Associativity）
当表达式中出现多个相同优先级的运算符时，结合性决定了它们的计算顺序。结合性可以是左结合（从左到右）或右结合（从右到左）。
左结合运算符：
- 大多数运算符是左结合的，例如 `+`、`-`、`*`、`/`、`%`、`<<`、`>>`、`>>>`、`&`、`^`、`|`、`&&`、`||`。
- **示例**：
```java
int result = 10 - 5 - 2; // 从左到右计算，(10 - 5) - 2 = 3 ```
右结合运算符： - 赋值运算符（`=`、`+=`、`-=` 等）和三元运算符（`?:`）是右结合的。
- **示例**：
```java
int a, b, c; a = b = c = 5; // 从右到左计算，c = 5, b = c, a = b
```
4. 类型转换规则（Type Conversion Rules）
在表达式中，操作数的类型可能会自动转换，以满足运算符的要求。类型转换规则包括隐式转换（自动类型提升）和显式转换（强制类型转换）。
4.1 隐式类型转换（自动类型提升）当操作数的类型不同时，Java会自动将较小的类型提升为较大的类型。
- **规则**： - `byte` -> `short` -> `int` -> `long` -> `float` -> `double` - `char` -> `int`
- **示例**： ```java
int a = 5; double b = 2.5; double result = a + b; // a 被提升为 double，结果是 7.5
```
4.2 显式类型转换（强制类型转换）当需要将较大的类型转换为较小的类型时，必须使用显式类型转换。- **示例**： ```java double a = 5.7; int b = (int) a; // b 的值为 5，小数部分被截断 ```---
5. 短路规则（Short-Circuit Evaluation）
对于逻辑与（`&&`）和逻辑或（`||`）运算符，Java采用短路规则：如果第一个操作数已经能够确定整个表达式的结果，则不会计算第二个操作数。
- **示例**：
```java
int a = 5;
if (a > 0 || a / 0 == 1) {
// 不会抛出异常，因为 a > 0 为 true，短路规则生效
System.out.println("Short-circuit!"); }
```---
6. 赋值运算符的类型转换
复合赋值运算符（如 `+=`、`-=`、`*=` 等）会自动进行类型转换，即使可能导致数据丢失。
- **示例**：
```java
byte b = 10; b += 1000;
// 等价于 b = (byte)(b + 1000); System.out.println(b); // -46（数据丢失） ```
7. 字符串连接规则
`+` 运算符在用于字符串时会被重载，用于字符串连接。如果其中一个操作数是字符串，另一个操作数会被自动转换为字符串。
- **示例**：
```java
String result = "The answer is " + 42;
// "The answer is 42" ```---
8. 三元运算符的类型推断
三元运算符（`?:`）的结果类型是根据两个操作数的类型推断的。如果两个操作数的类型不同，结果类型将是它们的最小公共超类。
- **示例**：
```java
Number result = true ? 1 : 2.0;
// 结果是 Double 类型 System.out.println(result.getClass());
// class java.lang.Double ```
9. 位运算符的特殊规则
位运算符（如 `&`、`|`、`^`、`~`、`<<`、`>>`、`>>>`）直接操作二进制位，适用于整数类型。位运算符直接进行二进制操作，效率极高，常被用于进行特殊计算中。
9.1 按位与（`&`）
- **功能**：对两个操作数的每一位进行与操作，结果为1当且仅当两个位都为1。
- **示例**：
```java
int a = 5; // 二进制：0101
int b = 3; // 二进制：0011
int result = a & b; // 结果：0001 (1)
- **应用场景**：? - 判断特定位是否为1。? - 掩码操作，提取特定位。9.2 按位或（`|`）
- **功能**：对两个操作数的每一位进行或操作，结果为1当且仅当至少一个位为1。
- **示例**：
```java
int a = 5; // 二进制：0101
int b = 3; // 二进制：0011
int result = a | b; // 结果：0111 (7) ```
- **应用场景**： - 设置特定位为1。 - 组合多个标志位。
9.3 按位异或（`^`）
- **功能**：对两个操作数的每一位进行异或操作，结果为1当且仅当两个位不同。
- **示例**：
```java
int a = 5; // 二进制：0101
int b = 3; // 二进制：0011
int result = a ^ b; // 结果：0110 (6)
```
- **应用场景**： - 交换两个变量的值。 - 切换特定位的状态。
9.4 按位取反（`~`）
- **功能**：对操作数的每一位进行取反操作，1变0，0变1。
- **示例**：
```java
int a = 5; // 二进制：0000 0101
int result = ~a; // 结果：1111 1010 (-6)
```
- **应用场景**： - 反转所有位。 - 计算补码。
9.5 左移（`<<`）
- **功能**：将操作数的二进制表示向左移动指定的位数，右侧空出的位用0填充。
- **示例**：
```java
int a = 5; // 二进制：0101
int result = a << 1; // 结果：1010 (10)
- **应用场景**：? - 快速乘以2的幂。? - 高效处理位掩码。9.6 算术右移（`>>`）- **功能**：将操作数的二进制表示向右移动指定的位数，左侧空出的位用符号位填充。- **示例**：? ```java? int a = -8; // 二进制：11111111111111111111111111111000? int result = a >> 1; // 结果：11111111111111111111111111111100 (-4)? ```- **应用场景**：? - 快速除以2的幂。? - 保留符号位。9.7 逻辑右移（`>>>`）- **功能**：将操作数的二进制表示向右移动指定的位数，左侧空出的位用0填充。- **示例**：? ```java? int a = -8; // 二进制：11111111111111111111111111111000? int result = a >>> 1; // 结果：01111111111111111111111111111100 (2147483644)? ```- **应用场景**：? - 无符号右移，忽略符号位。? - 处理无符号整数。---9.8 位运算符的常见应用场景快速乘除法
- **左移（`<<`）**：用于快速乘以2的幂。 ```java
int a = 5; int b = a << 1; // 10，相当于 a * 2 ```
- **右移（`>>`）**：用于快速除以2的幂。 ```java
int a = 10; int b = a >> 1; // 5，相当于 a / 2 ```
位掩码操作位运算符常用于位掩码操作，用于选择性地操作特定位。
- **设置位**：
```java
int flags = 0;
flags |= 1 << 2; // 设置第2位
```
- **清除位**：
```java
flags &= ~(1 << 2); // 清除第2位
```
- **切换位**：
```java
flags ^= 1 << 2; // 切换第2位 ```
快速判断奇偶
使用按位与运算符 `&` 可以快速判断一个数是否为偶数。
int a = 5;boolean isEven = (a & 1) == 0; // false，5是奇数```交换两个变量的值使用按位异或运算符 `^` 可以在不使用临时变量的情况下交换两个变量的值。```javaint a = 5, b = 10;a ^= b; b ^= a; a ^= b; // 交换后 a=10, b=5```快速计算绝对值使用位运算可以快速计算一个整数的绝对值。```javaint a = -5;int abs = (a + (a >> 31)) ^ (a >> 31); // 5```---9.9 注意事项- **符号位**：在右移操作中，`>>` 会保留符号位，而 `>>>` 会用0填充。- **数据类型**：位运算符仅适用于整数类型（`byte`、`short`、`int`、`long`）。- **性能优化**：位运算在底层操作中非常高效，但过度使用可能会降低代码的可读性。11. `instanceof` 运算符的继承关系`instanceof` 不仅可以检查对象是否是某个类的实例，还可以检查对象是否是某个类的子类的实例。
- **示例**：
```java
class Animal {} class Dog extends Animal {}
Animal myDog = new Dog(); System.out.println(myDog instanceof Dog); // true
System.out.println(myDog
instanceof Animal); // true
```
- **解释**：`instanceof` 运算符会检查对象的整个继承链，因此即使对象是子类的实例，它也会返回 `true`。
`instanceof` 使用注意点
`instanceof` 运算符在操作数为 `null` 时返回 `false`，而不是抛出异常。
- **示例**： ```java String str = null; if (str instanceof String) { // 结果为 false // ... } ```
- **解释**：`instanceof` 运算符在操作数为 `null` 时返回 `false`，因此可以安全地用于 `null` 检查。---
12. Lambda表达式与双冒号运算符
Lambda表达式
Java 8引入的Lambda表达式利用 `->` 运算符，使得函数式编程更加简洁。- **示例**： ```java List
双冒号运算符
双冒号 `::` 用于方法引用，进一步简化Lambda表达式的写法。- **示例**： ```java List
Java位运算符使用经验
1. 按位与（`&`）：
用于快速判断某个整数的特定位是否为1。 ```java int a = 5; // 0101 boolean isBitSet = (a & 1) != 0; // 判断最低位是否为1 ```2. 按位或（`|`）：
用于将多个标志位组合成一个整数。 ```java int READ = 1, WRITE = 2, EXECUTE = 4; int permissions = READ | WRITE; // 组合权限 ```3. 按位异或（`^`）：
用于交换两个变量的值。 ```java int a = 5, b = 10; a ^= b; b ^= a; a ^= b; // 交换a和b的值 ```4. 左移（`<<`）和右移（`>>`）：
用于快速乘以或除以2的幂。 ```java int a = 8; int b = a << 1; // 16，相当于a * 2 int c = a >> 1; // 4，相当于a / 2 ```5. 使用位运算代替乘除法： ```java int a = 10; int b = a << 1; // 20，相当于a * 2 int c = a >> 1; // 5，相当于a / 2 ```---
Java运算符其他注意点
Java 本身不支持用户自定义的运算符重载，但某些运算符在特定场景下已经“重载”了。例如：
`+` 运算符的重载- **字符串连接**：`+` 运算符在用于字符串时会被重载，用于字符串连接。 ```java String result = "Hello, " + "World!"; // 结果是 "Hello, World!" ```- **数值加法**：`+` 运算符用于数值加法。 ```java int sum = 5 + 3; // 结果是 8 ```
`+=` 运算符的重载- **字符串连接**：`+=` 运算符可以用于字符串连接。 ```java String str = "Hello"; str += " World!"; // 结果是 "Hello World!" ```- **数值加法**：`+=` 运算符用于数值加法。 ```java int a = 5; a += 3; // 结果是 8 ```
`==` 和 `!=` 运算符的重载- **引用比较**：`==` 和 `!=` 运算符用于比较对象的引用。 ```java String s1 = new String("hello"); String s2 = new String("hello"); System.out.println(s1 == s2); // false，比较的是引用 ```- **数值比较**：`==` 和 `!=` 运算符用于比较数值。 ```java int a = 5, b = 5; System.out.println(a == b); // true，比较的是值 ```---
2. 自动装箱与拆箱
Java 提供了自动装箱（Autoboxing）和拆箱（Unboxing）功能，使得基本数据类型和其对应的包装类可以无缝转换。这在使用运算符时非常有用。自动装箱通过 valueOf() 方法实现，自动拆箱通过 xxxValue() 方法实现。自动装箱：
将基本数据类型自动转换为包装类。 ```java Integer a = 5; // 自动装箱，等价于 Integer a = Integer.valueOf(5); ```
自动拆箱：
将包装类自动转换为基本数据类型。 ```java int b = a; // 自动拆箱，等价于 int b = a.intValue(); ```- **运算符中的自动拆箱**： ```java Integer a = 10, b = 20; int sum = a + b; // 自动拆箱后计算 ```---
3. 字符串连接的性能优化
虽然 `+` 运算符可以用于字符串连接，但在大量字符串拼接时，性能较差。Java 提供了 `StringBuilder` 和 `StringBuffer` 来优化字符串拼接。- **使用 `+` 运算符**： ```java String result = "Hello, " + "World!"; // 适用于少量字符串拼接 ```- **使用 `StringBuilder`**： ```java StringBuilder sb = new StringBuilder(); sb.append("Hello, ").append("World!"); String result = sb.toString(); // 适用于大量字符串拼接 ```
总结
Java中的运算符规则包括贪心规则、优先级、结合性、类型转换规则、短路规则等。理解这些规则可以帮助开发者编写更高效、更健壮的代码，并避免因运算符使用不当而导致的错误。
在实际编程中，建议使用括号明确表达式的优先级，以提高代码的可读性和可维护性。同时，掌握运算符的巧妙使用经验可以进一步提升代码的性能和简洁性。
关注一下吧
?