Java运算符及其优先级详解
本文让我们揭开 Java 运算符的神秘面纱，我会把各种运算符的用法逐一讲解给你。相信通过学习，你一定可以高效运用它们。
表格中，-x 是对 x 取反运算，x++ 或 x-- 是在表达式运算完后再给 x 加 1 或减 1。而 ++x 或 --x 是先给 x 加 1 或减 1 后再进行表达式运算。
示例代码如下：
示例代码如下：
关系运算符有 6 种：==、!=、>、<、>= 和 <=，具体说明如下表所示。
== 和 != 可以应用于基本数据类型和引用数据类型。当用于引用数据类型比较时，比较的是两个引用是否指向同一个对象，但在实际开发过程中，多数情况下只是比较对象的内容是否相等，不需要比较是否为同一个对象。
示例代码如下：
短路与（&&）和短路或（||）能够采用最优化的计算方式，从而提高效率。在实际编程时，应该优先考虑使用短路与和短路或。
示例代码如下：
位运算符有如下几个：&、|、^、~、>>、<< 和 >>>，其中 ~ 是一元运算符，其他都是二元运算符。具体说明如下表所示。
示例代码如下：
赋值运算符示例代码如下：
三元运算符的语法格式如下：
三元运算符示例代码如下：
需要注意的是，尽管三元运算符在某些情况下可以简化代码，但过度使用它可能会导致代码难以理解。因此，在使用三元运算符时应当谨慎，确保代码的可读性和清晰性。
在一些简单的条件判断场景下，三元运算符是一种便捷的替代方案，但对于复杂的条件判断，建议使用传统的 if else 语句，以保持代码的可读性和可维护性。
在 Java 中，不同运算符有不同的优先级，这会影响表达式的计算顺序。以下是 Java 中一些常见的运算符（按照优先级从高到低的顺序）：
在表达式中使用括号可以改变运算符的优先级。括号内的表达式会先于其他运算符进行计算。
演示不同运算符的优先级的示例代码如下：
Java算术运算符
在 Java 中，算术运算符可以分为一元运算符和二元运算符。一元运算符是指只需要一个操作数进行运算的运算符，而二元运算符是指需要两个操作数进行运算的运算符。1) 一元算术运算符
先介绍一元算术运算符，具体说明如下表所示。| 运算符 | 名称 | 说明 | 例子 |
|---|---|---|---|
| - | 取反符号 | 取反运算 | y = -x |
| ++ | 自加一 | 先取值再加一，或先加一再取值 | x++或++x |
| -- | 自减一 | 先取值再减一，或先减一再取值 | x--或--x |
表格中，-x 是对 x 取反运算，x++ 或 x-- 是在表达式运算完后再给 x 加 1 或减 1。而 ++x 或 --x 是先给 x 加 1 或减 1 后再进行表达式运算。
示例代码如下：
// 一元运算符
public class Main {
public static void main(String[] args) {
int x = 5;
int positiveValue = +x; // 正号运算符，positiveValue 的值为 5
int negativeValue = -x; // 负号运算符，negativeValue 的值为 -5
int prefixIncrement = ++x; // 前缀自增运算符，先将 x 增加 1，然后赋值，prefixIncrement 的值为 6，x 的值变为 6
int postfixDecrement = x--; // 后缀自减运算符，先使用 x 的当前值（6）赋值，然后将 x 减少 1，postfixDecrement 的值为 6，x 的值变为 5
System.out.println("positiveValue(正值): " + positiveValue);
System.out.println("negativeValue(负值): " + negativeValue);
System.out.println("prefixIncrement(前缀自增): " + prefixIncrement);
System.out.println("postfixDecrement(后缀自减): " + postfixDecrement);
System.out.println("postfixDecrement: " + postfixDecrement);
}
}
程序运行结果：
positiveValue(正值): 5
negativeValue(负值): -5
prefixIncrement(前缀自增): 6
postfixDecrement(后缀自减): 6
postfixDecrement: 6
2) 二元算术运算符
二元算术运算符包括 +、-、*、/ 和 %，这些运算符对数值类型数据都有效。具体说明如下表所示。| 运算符 | 名称 | 例子 | 说明 |
|---|---|---|---|
| + | 加 | x + y | 求 x 加 y 的和，还可用于 String 类型，进行字符串连接操作 |
| - | 减 | x - y | 求 x 减 y 的差 |
| * | 乘 | x * y | 求 x 乘以 y 的积 |
| / | 除 | x / y | 求 x 除以 y 的商 |
| % | 取余 | x % y | 求 x 除以 y 的余数 |
示例代码如下：
public class BinaryArithmeticOperators {
public static void main(String[] args) {
// 加法运算符
int x = 5;
int y = 10;
int sum = x + y; // sum 的值为 15，即 x 和 y 的和
System.out.println("sum(和): " + sum);
// 减法运算符
int a = 10;
int b = 5;
int difference = a - b; // difference 的值为 5，即 a 减去 b 的结果
System.out.println("difference(差): " + difference);
// 乘法运算符
int m = 2;
int n = 3;
int product = m * n; // product 的值为 6，即 m 和 n 的乘积
System.out.println("product(积): " + product);
// 除法运算符
int p = 10;
int q = 2;
int quotient = p / q; // quotient 的值为 5，即 p 除以 q 的结果
System.out.println("quotient(商): " + quotient);
// 取模运算符
int r = 10;
int s = 3;
int remainder = r % s; // remainder 的值为 1，即 r 除以 s 的余数
System.out.println("remainder(余数): " + remainder);
}
}
程序运行结果：
sum(和): 15
difference(差): 5
product(积): 6
quotient(商): 5
remainder(余数): 1
Java关系运算符
关系运算（也称为比较运算符）是比较两个表达式大小关系的运算，它属于二元运算符，它的结果是布尔类型数据，即 true 或 false。关系运算符有 6 种：==、!=、>、<、>= 和 <=，具体说明如下表所示。
| 运算符 | 名称 | 例子 | 说明 |
|---|---|---|---|
| == | 等于 | x == y | x 等于 y 时返回 true，否则返回 false。可以应用于基本数据类型和引用数据类型 |
| != | 不等于 | x != y | 与 == 相反 |
| > | 大于 | x > y | x 大于 y 时返回 true，否则返回 false，只应用于基本数据类型 |
| < | 小于 | x < y | x 小于 y 时返回 true，否则返回 false，只应用于基本数据类型 |
| >= | 大于等于 | x >= y | x 大于等于 y 时返回 true，否则返回 false，只应用于基本数据类型 |
| <= | 小于等于 | x <= y | x 小于等于 y 时返回 true，否则返回 false，只应用于基本数据类型 |
== 和 != 可以应用于基本数据类型和引用数据类型。当用于引用数据类型比较时，比较的是两个引用是否指向同一个对象，但在实际开发过程中，多数情况下只是比较对象的内容是否相等，不需要比较是否为同一个对象。
示例代码如下：
public class RelationalOperatorsExample {
public static void main(String[] args) {
int a = 5;
int b = 10;
// 等于运算符
boolean isEqual = (a == b);
System.out.println("a == b : " + isEqual); // 输出: a == b : false
// 不等于运算符
boolean isNotEqual = (a != b);
System.out.println("a != b : " + isNotEqual); // 输出: a != b : true
// 大于运算符
boolean isGreater = (a > b);
System.out.println("a > b : " + isGreater); // 输出: a > b : false
// 小于运算符
boolean isLess = (a < b);
System.out.println("a < b : " + isLess); // 输出: a < b : true
// 大于等于运算符
boolean isGreaterOrEqual = (a >= b);
System.out.println("a >= b : " + isGreaterOrEqual); // 输出: a >= b : false
// 小于等于运算符
boolean isLessOrEqual = (a <= b);
System.out.println("a <= b : " + isLessOrEqual); // 输出: a <= b : true
}
}
程序运行结果：
a == b : false
a != b : true
a > b : false
a < b : true
a >= b : false
a <= b : true
Java逻辑运算符
逻辑运算符用于对布尔型变量进行运算，其结果也是布尔型。具体说明如下表所示。| 运算符 | 名称 | 例子 | 说明 |
|---|---|---|---|
| ! | 逻辑非 | !x | x 为 true 时，值为 false，x 为 false 时，值为 true |
| & | 逻辑与 | x & y | xy 全为 true 时，计算结果为 true，否则为 false |
| | | 逻辑或 | x | y | xy 全为 false 时，计算结果为 false，否则为 true |
| && | 短路与 | x && y | xy 全为 true 时，计算结果为 true，否则为 false。&& 与 & 的区别：如果 x 为 false，则不计算 y（因为不论 y 为何值，结果都为 false） |
| || | 短路或 | x || y | xy 全为 false 时，计算结果为 false，否则为 true。|| 与 | 的区别：如果 x 为 true，则不计算 y（因为不论 y 为何值，结果都为 true） |
短路与（&&）和短路或（||）能够采用最优化的计算方式，从而提高效率。在实际编程时，应该优先考虑使用短路与和短路或。
示例代码如下：
public class LogicalOperatorsExample {
public static void main(String[] args) {
// 短路与(&&&)示例
int num1 = 5, num2 = 10;
if (num1 > 0 && num2 < 15) {
System.out.println("两个条件都为真。");
} else {
System.out.println("至少有一个条件为假。");
}
// 短路或(||)示例
int age = 25;
if (age < 18 || age > 60) {
System.out.println("年龄要么小于18岁，要么大于60岁。");
} else {
System.out.println("年龄在18岁到60岁之间。");
}
// 逻辑非(!)示例
boolean isRaining = false;
if (!isRaining) {
System.out.println("天气不是下雨，你可以出去。");
} else {
System.out.println("天气正在下雨，最好待在室内。");
}
// 复合逻辑表达式示例
int num3 = 40;
if (num1 > num2 && num2 > num3) {
System.out.println("所有数字都是降序排列的。");
} else if (num1 < num2 && num2 < num3) {
System.out.println("所有数字都是升序排列的。");
} else {
System.out.println("数字排列是随机的。");
}
}
}
程序运行结果：
两个条件都为真。
年龄在18岁到60岁之间。
天气不是下雨，你可以出去。
所有数字都是升序排列的。
Java位运算符
位运算是以二进制的位（bit）为单位进行运算的，操作数和结果都是整型数据。位运算符有如下几个：&、|、^、~、>>、<< 和 >>>，其中 ~ 是一元运算符，其他都是二元运算符。具体说明如下表所示。
| 运算符 | 名称 | 例子 | 说明 |
|---|---|---|---|
| ~ | 位反 | ~x | 将 x 的值按位取反 |
| & | 位与 | x & y | x 与 y 进行位与运算 |
| | | 位或 | x | y | x 与 y 进行位或运算 |
| ^ | 位异或 | x ^ y | x 与 y 进行位异或运算 |
| >> | 有符号右移 | x >> y | x 右移 y 位，高位采用符号位补位 |
| << | 左移 | x << y | x 左移 y 位，低位用 0 补位 |
| >>> | 无符号右移 | x >>> y | x 右移 y 位，高位用 0 补位 |
示例代码如下：
public class BitwiseOperatorsExample {
public static void main(String[] args) {
int num1 = 5; // 二进制表示为 0000 0101
int num2 = 9; // 二进制表示为 0000 1001
// 按位与(&)
int resultAnd = num1 & num2; // 结果为 0000 0001(1)
System.out.println("按位与(&)结果: " + resultAnd);
// 按位或(|)
int resultOr = num1 | num2; // 结果为 0000 1101(13)
System.out.println("按位或(|)结果: " + resultOr);
// 按位异或(^)
int resultXor = num1 ^ num2; // 结果为 0000 1100(12)
System.out.println("按位异或(^)结果: " + resultXor);
// 取反(~)
int resultNotNum1 = ~num1; // 结果为 1111 1010(-6)
int resultNotNum2 = ~num2; // 结果为 1111 0110(-10)
System.out.println("取反(~)num1 结果: " + resultNotNum1);
System.out.println("取反(~)num2 结果: " + resultNotNum2);
// 左移(<<)
int resultLeftShift = num1 << 2; // 结果为 0001 0100(20)
System.out.println("左移(<<)结果: " + resultLeftShift);
// 无符号右移(>>>)
int resultLogicalRightShift = num1 >>> 1; // 结果为 0000 0010(2)
System.out.println("无符号右移(>>>)结果: " + resultLogicalRightShift);
}
}
程序运行结果：
按位与(&)结果: 1
按位或(|)结果: 13
按位异或(^)结果: 12
取反(~)num1 结果: -6
取反(~)num2 结果: -10
左移(<<)结果: 20
无符号右移(>>>)结果: 2
Java赋值运算符
赋值运算符只是一种简写，一般用于变量自身的变化。具体说明如下表所示。| 运算符 | 名称 | 例子 |
|---|---|---|
| += | 加赋值 | a += b, a += b + 3 |
| -= | 减赋值 | a -= b |
| *= | 乘赋值 | a *= b |
| /= | 除赋值 | a /= b |
| %= | 取余赋值 | a %= b |
| &= | 位与赋值 | x &= y |
| |= | 位或赋值 | x |= y |
| ^= | 位异或赋值 | x ^= y |
| 左移赋值 | x <<= y | |
| >= | 右移赋值 | x >>= y |
| >>= | 无符号右移赋值 | x >>>= y |
赋值运算符示例代码如下：
public class AssignmentOperatorsExample {
public static void main(String[] args) {
int num1 = 10;
int num2 = 5;
// 等号赋值
int result = num1;
System.out.println("等号赋值结果:" + result);
// 复合赋值运算符
num1 += num2; // 相当于 num1 = num1 + num2, 结果为 15
System.out.println("+= 复合赋值结果:" + num1);
num1 -= num2; // 相当于 num1 = num1 - num2, 结果为 10
System.out.println("-= 复合赋值结果:" + num1);
num1 *= num2; // 相当于 num1 = num1 * num2, 结果为 50
System.out.println("*= 复合赋值结果:" + num1);
num1 /= num2; // 相当于 num1 = num1 / num2, 结果为 10
System.out.println("/= 复合赋值结果:" + num1);
num1 %= num2; // 相当于 num1 = num1 % num2, 结果为 0
System.out.println("%= 复合赋值结果:" + num1);
}
}
程序运行结果：
等号赋值结果:10
+= 复合赋值结果:15
-= 复合赋值结果:10
*= 复合赋值结果:50
/= 复合赋值结果:10
%= 复合赋值结果:0
Java三元运算符
在 Java 中，三元运算符是一种特殊的运算符，也称为条件运算符。它允许我们在一个表达式中根据条件的真假来选择不同的值。三元运算符的语法格式如下：
条件表达式 ? 表达式1 : 表达式2;其中，条件表达式是一个布尔表达式，如果条件表达式的值为真，则返回“表达式1”的值，否则返回“表达式2”的值。注意，“表达式1”和“表达式2”的类型必须是兼容的，即类型转换是允许的。
三元运算符示例代码如下：
public class TernaryOperatorExample {
public static void main(String[] args) {
int num = 5;
String result = (num > 0) ? "正数" : "非正数";
System.out.println("结果:" + result);
}
}
程序运行输出结果如下：
结果:正数
在这个例子中，我们使用三元运算符来判断变量 num 是否为正数，如果是正数，则返回字符串"正数"，否则返回字符串"非正数"。根据 num 的值，程序会输出相应的结果。需要注意的是，尽管三元运算符在某些情况下可以简化代码，但过度使用它可能会导致代码难以理解。因此，在使用三元运算符时应当谨慎，确保代码的可读性和清晰性。
在一些简单的条件判断场景下，三元运算符是一种便捷的替代方案，但对于复杂的条件判断，建议使用传统的 if else 语句，以保持代码的可读性和可维护性。
Java运算符优先级
运算符优先级定义了哪些运算符会先于其他运算符进行计算。如果表达式中有多个运算符，优先级高的运算符会先被计算，然后再计算优先级较低的运算符。在 Java 中，不同运算符有不同的优先级，这会影响表达式的计算顺序。以下是 Java 中一些常见的运算符（按照优先级从高到低的顺序）：
- 一元运算符（如：++，-，!）：优先级最高，会在其他运算符之前被计算。
- 算术运算符（如：*，/，%，+，-）：在一元运算符之后，优先级较高。
- 关系运算符（如：>, <, >=, <=, ==, !=）：在算术运算符之后，优先级较高。
- 逻辑运算符（如：&&, ||）：在关系运算符之后，优先级较低。
- 赋值运算符（如：=，+=，-=，*=，/=，%=）：在逻辑运算符之后，优先级较低。
- 条件运算符（如三元运算符：?:）：在赋值运算符之后，优先级最低。
在表达式中使用括号可以改变运算符的优先级。括号内的表达式会先于其他运算符进行计算。
演示不同运算符的优先级的示例代码如下：
public class OperatorPrecedenceExample {
public static void main(String[] args) {
// 1. 一元运算符
int x = 5;
int y = ++x * 2; // x 先加 1,然后再乘以 2
System.out.println("y = " + y); // 输出: y = 12
// 2. 算术运算符
int a = 10, b = 4;
int result1 = a + b * 2; // 先计算 b * 2, 再加上 a 的值
int result2 = (a + b) * 2; // 先计算 a + b, 再乘以 2
System.out.println("result1 = " + result1); // 输出: result1 = 18
System.out.println("result2 = " + result2); // 输出: result2 = 28
// 3. 关系运算符
int num1 = 5, num2 = 10;
boolean isGreater = num1 > num2; // 检查 num1 是否大于 num2
System.out.println("isGreater = " + isGreater); // 输出: isGreater = false
// 4. 逻辑运算符
boolean p = true, q = false;
boolean result3 = p && q; // p 和 q 都为 true 时, 结果为 true, 否则为 false
boolean result4 = p || q; // p 和 q 有一个为 true 时, 结果为 true, 否则为 false
System.out.println("result3 = " + result3); // 输出: result3 = false
System.out.println("result4 = " + result4); // 输出: result4 = true
// 5. 赋值运算符
int num = 10;
num += 5; // 相当于 num = num + 5;
System.out.println("num = " + num); // 输出: num = 15
// 6. 条件运算符(三元运算符)
int m = 8, n = 12;
int max = (m > n) ? m : n; // 如果 m 大于 n, 则 max 等于 m, 否则 max 等于 n
System.out.println("max = " + max); // 输出: max = 12
}
}
运行结果为：
y = 12
result1 = 18
result2 = 28
isGreater = false
result3 = false
result4 = true
num = 15
max = 12
ICP备案：
公安联网备案：