吊打面试官(四)--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<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5); numbers.forEach(x -> System.out.println(x / 100.0)); ```

双冒号运算符

双冒号 `::` 用于方法引用，进一步简化Lambda表达式的写法。- **示例**： ```java List<String> strings = Arrays.asList("1", "2", "3"); List<Integer> numbers = strings.stream() .map(Integer::parseInt) .collect(Collectors.toList()); ```

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中的运算符规则包括贪心规则、优先级、结合性、类型转换规则、短路规则等。理解这些规则可以帮助开发者编写更高效、更健壮的代码，并避免因运算符使用不当而导致的错误。

在实际编程中，建议使用括号明确表达式的优先级，以提高代码的可读性和可维护性。同时，掌握运算符的巧妙使用经验可以进一步提升代码的性能和简洁性。

关注一下吧