Java入门到精通-05 运算符与表达式
·
目录
🔢 05 运算符与表达式
更新日期：2026年5月
版权声明：本文为原创文章，转载请注明出处。© 2026 Java入门到精通系列
一、什么是运算符与表达式
1.1 运算符（Operator）
运算符是用于对变量和值进行操作的特殊符号。Java提供了丰富的运算符来满足各种计算需求。
1.2 表达式（Expression）
表达式是由运算符和操作数组成的式子，计算后会得到一个值。
// 表达式示例
int result = 10 + 5; // 10 + 5 是表达式，结果为15
boolean flag = age >= 18; // age >= 18 是表达式，结果为true或false
int max = (a > b) ? a : b; // 三元表达式
1.3 运算符分类总览
| 类别 | 运算符 | 说明 |
|---|---|---|
| 算术运算符 | + - * / % ++ -- |
数学计算 |
| 赋值运算符 | = += -= *= /= %= |
赋值操作 |
| 比较运算符 | == != > < >= <= |
比较大小 |
| 逻辑运算符 | && || ! & | ^ |
逻辑判断 |
| 位运算符 | & | ^ ~ << >> >>> |
二进制操作 |
| 三元运算符 | ? : |
条件选择 |
| instanceof | instanceof |
类型检查 |
二、算术运算符
2.1 基本算术运算符
| 运算符 | 名称 | 说明 | 示例 | 结果 |
|---|---|---|---|---|
+ |
加 | 加法运算 | 5 + 3 |
8 |
- |
减 | 减法运算 | 5 - 3 |
2 |
* |
乘 | 乘法运算 | 5 * 3 |
15 |
/ |
除 | 除法运算 | 5 / 3 |
1（整数除法） |
% |
取模 | 求余数 | 5 % 3 |
2 |
public class ArithmeticDemo {
public static void main(String[] args) {
int a = 10;
int b = 3;
System.out.println("a + b = " + (a + b)); // 13
System.out.println("a - b = " + (a - b)); // 7
System.out.println("a * b = " + (a * b)); // 30
System.out.println("a / b = " + (a / b)); // 3（整数除法，小数部分丢失）
System.out.println("a % b = " + (a % b)); // 1
// 浮点数除法
double x = 10.0;
double y = 3.0;
System.out.println("x / y = " + (x / y)); // 3.3333333333333335
}
}
2.2 整数除法的陷阱
⚠️ 重要提醒：两个整数相除，结果仍然是整数，小数部分会被直接截断！
int result1 = 10 / 3; // 结果是3，不是3.333...
int result2 = 7 / 2; // 结果是3，不是3.5
int result3 = -10 / 3; // 结果是-3，向零取整
// 如果想要精确结果，至少一个操作数要是浮点数
double result4 = 10.0 / 3; // 结果是3.3333333333333335
double result5 = 10 / 3.0; // 结果是3.3333333333333335
double result6 = (double) 10 / 3; // 强制转换，结果是3.3333333333333335
2.3 取模运算符
取模运算（%）返回除法的余数。
public class ModDemo {
public static void main(String[] args) {
// 基本取模
System.out.println(10 % 3); // 1
System.out.println(10 % 5); // 0（整除）
System.out.println(7 % 4); // 3
// 负数取模：结果的符号与被除数相同
System.out.println(-10 % 3); // -1
System.out.println(10 % -3); // 1
// 实用场景
// 1. 判断奇偶数
int num = 7;
if (num % 2 == 0) {
System.out.println(num + "是偶数");
} else {
System.out.println(num + "是奇数");
}
// 2. 循环取值（0-9循环）
for (int i = 0; i < 20; i++) {
System.out.print(i % 10 + " "); // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
}
}
}
2.4 自增自减运算符
++ 和 -- 是单目运算符，分别将变量的值加1和减1。
| 运算符 | 名称 | 说明 |
|---|---|---|
i++ |
后自增 | 先使用i的值，然后i加1 |
++i |
前自增 | 先i加1，然后使用i的值 |
i-- |
后自减 | 先使用i的值，然后i减1 |
--i |
前自减 | 先i减1，然后使用i的值 |
public class IncrementDemo {
public static void main(String[] args) {
// 后自增：先用后加
int a = 5;
int b = a++; // b = 5, a = 6
System.out.println("a = " + a + ", b = " + b); // a = 6, b = 5
// 前自增：先加后用
int c = 5;
int d = ++c; // d = 6, c = 6
System.out.println("c = " + c + ", d = " + d); // c = 6, d = 6
// 自减同理
int x = 10;
int y = x--; // y = 10, x = 9
int z = --x; // z = 8, x = 8
// 经典面试题
int i = 10;
int result = i++ + ++i + i-- + --i;
// 分析：
// i++ -> 使用10，i变为11
// ++i -> i变为12，使用12
// i-- -> 使用12，i变为11
// --i -> i变为10，使用10
// result = 10 + 12 + 12 + 10 = 44
System.out.println("result = " + result); // 44
System.out.println("i = " + i); // 10
}
}
三、赋值运算符
3.1 基本赋值运算符
int a = 10; // 将10赋值给变量a
3.2 复合赋值运算符
| 运算符 | 等价于 | 示例 | 说明 |
|---|---|---|---|
+= |
a = a + b |
a += 5 |
加后赋值 |
-= |
a = a - b |
a -= 5 |
减后赋值 |
*= |
a = a * b |
a *= 5 |
乘后赋值 |
/= |
a = a / b |
a /= 5 |
除后赋值 |
%= |
a = a % b |
a %= 5 |
取模后赋值 |
&= |
a = a & b |
a &= 5 |
按位与后赋值 |
|= |
a = a | b |
a |= 5 |
按位或后赋值 |
^= |
a = a ^ b |
a ^= 5 |
按位异或后赋值 |
<<= |
a = a << b |
a <<= 2 |
左移后赋值 |
>>= |
a = a >> b |
a >>= 2 |
右移后赋值 |
public class AssignmentDemo {
public static void main(String[] args) {
int a = 10;
a += 5; // a = a + 5 = 15
System.out.println("a += 5: " + a);
a -= 3; // a = a - 3 = 12
System.out.println("a -= 3: " + a);
a *= 2; // a = a * 2 = 24
System.out.println("a *= 2: " + a);
a /= 4; // a = a / 4 = 6
System.out.println("a /= 4: " + a);
a %= 4; // a = a % 4 = 2
System.out.println("a %= 4: " + a);
}
}
⚠️ 复合赋值运算符的隐式类型转换：
byte b = 10;
// b = b + 5; // 编译错误！b + 5的结果是int类型
b += 5; // 正确！复合赋值运算符会自动进行类型转换
System.out.println(b); // 15
四、比较运算符
比较运算符用于比较两个值，返回boolean类型的结果（true或false）。
| 运算符 | 名称 | 说明 | 示例 | 结果 |
|---|---|---|---|---|
== |
等于 | 判断是否相等 | 5 == 5 |
true |
!= |
不等于 | 判断是否不等 | 5 != 3 |
true |
> |
大于 | 判断是否大于 | 5 > 3 |
true |
< |
小于 | 判断是否小于 | 5 < 3 |
false |
>= |
大于等于 | 判断是否大于等于 | 5 >= 5 |
true |
<= |
小于等于 | 判断是否小于等于 | 5 <= 3 |
false |
public class ComparisonDemo {
public static void main(String[] args) {
int a = 10;
int b = 20;
System.out.println("a == b: " + (a == b)); // false
System.out.println("a != b: " + (a != b)); // true
System.out.println("a > b: " + (a > b)); // false
System.out.println("a < b: " + (a < b)); // true
System.out.println("a >= b: " + (a >= b)); // false
System.out.println("a <= b: " + (a <= b)); // true
// 字符串比较（注意==和equals的区别）
String s1 = new String("hello");
String s2 = new String("hello");
System.out.println("s1 == s2: " + (s1 == s2)); // false（比较引用）
System.out.println("s1.equals(s2): " + s1.equals(s2)); // true（比较内容）
// 浮点数比较（慎用==）
double d1 = 0.1 + 0.2;
double d2 = 0.3;
System.out.println("d1 == d2: " + (d1 == d2)); // false（精度问题）
System.out.println("d1: " + d1); // 0.30000000000000004
}
}
⚠️ 注意事项：
==比较基本类型时比较的是值，比较引用类型时比较的是引用地址- 浮点数比较不要直接使用
==，应该使用误差范围比较 - 字符串内容比较请使用
equals()方法
五、逻辑运算符
5.1 逻辑运算符总览
| 运算符 | 名称 | 说明 | 短路特性 |
|---|---|---|---|
&& |
短路与 | 两个条件都为true才为true | 是（左边为false，右边不执行） |
|| |
短路或 | 有一个条件为true就为true | 是（左边为true，右边不执行） |
! |
逻辑非 | 取反 | - |
& |
逻辑与 | 两个条件都为true才为true | 否（两边都执行） |
| |
逻辑或 | 有一个条件为true就为true | 否（两边都执行） |
^ |
逻辑异或 | 两个条件不同才为true | - |
5.2 短路与&&和短路或||
public class LogicalDemo {
public static void main(String[] args) {
int a = 10;
int b = 20;
int c = 30;
// 短路与&&：两边都为true，结果才为true
System.out.println(a < b && b < c); // true
System.out.println(a > b && b < c); // false（左边为false，右边不执行）
// 短路或||：有一个为true，结果就为true
System.out.println(a > b || b < c); // true（左边为false，继续判断右边）
System.out.println(a < b || b > c); // true（左边为true，右边不执行）
// 逻辑非!：取反
System.out.println(!(a > b)); // true（a > b为false，取反为true）
// 短路特性演示
int x = 5;
int y = 10;
// 由于x > 10为false，短路后++y不会执行
if (x > 10 && ++y > 10) {
System.out.println("条件成立");
}
System.out.println("y = " + y); // y = 10（y没有被自增）
}
}
5.3 非短路与&和非短路或|
public class NonShortCircuitDemo {
public static void main(String[] args) {
int a = 10;
int b = 20;
// 非短路与&：两边都会执行
if (a > 5 & ++b > 20) {
System.out.println("条件成立");
}
System.out.println("b = " + b); // b = 21（++b被执行了）
// 非短路或|：两边都会执行
int c = 10;
if (a < 5 | ++c > 5) {
System.out.println("条件成立");
}
System.out.println("c = " + c); // c = 11（++c被执行了）
}
}
5.4 逻辑异或^
public class XorDemo {
public static void main(String[] args) {
// 异或：两个条件不同为true，相同为false
System.out.println(true ^ true); // false
System.out.println(true ^ false); // true
System.out.println(false ^ true); // true
System.out.println(false ^ false); // false
// 实际应用：交换两个变量的值（不使用第三方变量）
int a = 5;
int b = 10;
a = a ^ b;
b = a ^ b;
a = a ^ b;
System.out.println("a = " + a + ", b = " + b); // a = 10, b = 5
}
}
六、位运算符
位运算符直接对整数的二进制位进行操作。
6.1 位运算符总览
| 运算符 | 名称 | 说明 | 示例 |
|---|---|---|---|
& |
按位与 | 两个位都为1才为1 | 5 & 3 = 1 |
| |
按位或 | 有一个位为1就为1 | 5 | 3 = 7 |
^ |
按位异或 | 两个位不同为1 | 5 ^ 3 = 6 |
~ |
按位取反 | 0变1，1变0 | ~5 = -6 |
<< |
左移 | 各位左移，低位补0 | 5 << 1 = 10 |
>> |
右移 | 各位右移，高位补符号位 | 5 >> 1 = 2 |
>>> |
无符号右移 | 各位右移，高位补0 | -1 >>> 1 = 2147483647 |
6.2 位运算详解
public class BitOperationDemo {
public static void main(String[] args) {
int a = 5; // 二进制：00000000 00000000 00000000 00000101
int b = 3; // 二进制：00000000 00000000 00000000 00000011
// 按位与&：两个都为1才为1
System.out.println("5 & 3 = " + (a & b)); // 1（00000001）
// 按位或|：有一个为1就为1
System.out.println("5 | 3 = " + (a | b)); // 7（00000111）
// 按位异或^：不同为1
System.out.println("5 ^ 3 = " + (a ^ b)); // 6（00000110）
// 按位取反~：0变1，1变0
System.out.println("~5 = " + (~a)); // -6
// 左移<<：相当于乘以2的n次方
System.out.println("5 << 1 = " + (a << 1)); // 10（5 * 2）
System.out.println("5 << 2 = " + (a << 2)); // 20（5 * 4）
// 右移>>：相当于除以2的n次方
System.out.println("5 >> 1 = " + (a >> 1)); // 2（5 / 2）
System.out.println("5 >> 2 = " + (a >> 2)); // 1（5 / 4）
// 无符号右移>>>
System.out.println("-1 >>> 1 = " + (-1 >>> 1)); // 2147483647
}
}
6.3 位运算的实际应用
public class BitOperationPractice {
public static void main(String[] args) {
// 1. 判断奇偶数（比%效率高）
int num = 7;
if ((num & 1) == 0) {
System.out.println(num + "是偶数");
} else {
System.out.println(num + "是奇数");
}
// 2. 交换两个变量的值
int x = 10, y = 20;
x ^= y;
y ^= x;
x ^= y;
System.out.println("x = " + x + ", y = " + y); // x=20, y=10
// 3. 不使用+号实现加法
int p = 15, q = 25;
while (q != 0) {
int carry = p & q; // 进位
p = p ^ q; // 无进位加法
q = carry << 1; // 进位左移
}
System.out.println("15 + 25 = " + p); // 40
// 4. 权限系统（位掩码）
final int READ = 1; // 001
final int WRITE = 2; // 010
final int EXECUTE = 4; // 100
int permission = READ | WRITE; // 授予读写权限：011
System.out.println("有读权限: " + ((permission & READ) != 0)); // true
System.out.println("有写权限: " + ((permission & WRITE) != 0)); // true
System.out.println("有执行权限: " + ((permission & EXECUTE) != 0)); // false
// 添加执行权限
permission |= EXECUTE; // 111
System.out.println("添加后有执行权限: " + ((permission & EXECUTE) != 0)); // true
// 移除写权限
permission &= ~WRITE; // 101
System.out.println("移除后有写权限: " + ((permission & WRITE) != 0)); // false
}
}
七、三元运算符
7.1 基本语法
条件表达式 ? 表达式1 : 表达式2
如果条件表达式为true，返回表达式1的值；否则返回表达式2的值。
7.2 使用示例
public class TernaryDemo {
public static void main(String[] args) {
// 基本使用
int a = 10;
int b = 20;
int max = (a > b) ? a : b;
System.out.println("最大值：" + max); // 20
// 判断奇偶数
int num = 7;
String result = (num % 2 == 0) ? "偶数" : "奇数";
System.out.println(num + "是" + result); // 7是奇数
// 求三个数的最大值
int x = 10, y = 30, z = 20;
int maxOfThree = (x > y) ? ((x > z) ? x : z) : ((y > z) ? y : z);
System.out.println("三个数的最大值：" + maxOfThree); // 30
// 与字符串拼接结合
int score = 85;
String level = (score >= 60) ? "及格" : "不及格";
System.out.println("成绩等级：" + level);
// 实际应用：绝对值
int value = -10;
int abs = (value >= 0) ? value : -value;
System.out.println("绝对值：" + abs); // 10
}
}
⚠️ 注意事项：
- 三元运算符必须有返回值，不能单独作为语句使用
- 表达式1和表达式2的类型应该兼容
- 不要嵌套太深，影响代码可读性
八、instanceof运算符
instanceof用于判断一个对象是否是某个类的实例。
public class InstanceofDemo {
public static void main(String[] args) {
String str = "Hello";
Object obj = str;
// 判断类型
System.out.println(str instanceof String); // true
System.out.println(str instanceof Object); // true
System.out.println(obj instanceof String); // true
System.out.println(obj instanceof Integer); // false
// Java 16+ 模式匹配（Pattern Matching）
if (obj instanceof String s) {
System.out.println("字符串长度：" + s.length()); // 5
}
// 实际应用：安全的类型转换
Object data = "Hello World";
if (data instanceof String text) {
System.out.println(text.toUpperCase()); // HELLO WORLD
}
}
}
九、运算符优先级
运算符优先级决定了表达式中运算的执行顺序。优先级高的先执行。
| 优先级 | 运算符 | 说明 | 结合性 |
|---|---|---|---|
| 1 | () [] . |
括号、数组下标、成员访问 | 左到右 |
| 2 | ! ~ ++ -- +(正) -(负) |
一元运算符 | 右到左 |
| 3 | * / % |
乘除取模 | 左到右 |
| 4 | + - |
加减 | 左到右 |
| 5 | << >> >>> |
移位运算 | 左到右 |
| 6 | < <= > >= instanceof |
关系运算 | 左到右 |
| 7 | == != |
相等运算 | 左到右 |
| 8 | & |
按位与 | 左到右 |
| 9 | ^ |
按位异或 | 左到右 |
| 10 | | |
按位或 | 左到右 |
| 11 | && |
短路与 | 左到右 |
| 12 | || |
短路或 | 左到右 |
| 13 | ? : |
三元运算符 | 右到左 |
| 14 | = += -= *= /= %= 等 |
赋值运算符 | 右到左 |
public class PrecedenceDemo {
public static void main(String[] args) {
// 示例1：算术运算优先级
int result1 = 2 + 3 * 4; // 先乘后加，结果为14
int result2 = (2 + 3) * 4; // 括号优先，结果为20
System.out.println("result1 = " + result1);
System.out.println("result2 = " + result2);
// 示例2：逻辑运算优先级
boolean result3 = true || false && false; // &&优先级高于||，结果为true
boolean result4 = (true || false) && false; // 括号改变优先级，结果为false
System.out.println("result3 = " + result3);
System.out.println("result4 = " + result4);
// 示例3：复杂表达式
int a = 5, b = 10, c = 15;
boolean result5 = a > b && b < c || a == b;
// 等价于：(a > b && b < c) || (a == b)
// = (false && true) || false
// = false || false
// = false
System.out.println("result5 = " + result5);
// 建议：复杂表达式使用括号，提高可读性
boolean result6 = (a > b) && (b < c) || (a == b);
System.out.println("result6 = " + result6);
}
}
💡 最佳实践：当表达式复杂时，使用括号明确优先级，即使不是必须的。这样可以提高代码可读性，避免歧义。
十、常见面试题
面试题1：==和equals()的区别？
String s1 = "hello";
String s2 = "hello";
String s3 = new String("hello");
System.out.println(s1 == s2); // true（字符串常量池，同一对象）
System.out.println(s1 == s3); // false（不同对象）
System.out.println(s1.equals(s3)); // true（内容相同）
答案：==比较基本类型时比较值，比较引用类型时比较内存地址。equals()默认也是比较地址，但String等类重写了该方法来比较内容。
面试题2：&&和&的区别？
答案：
&&是短路与，左边为false时右边不执行&是非短路与，两边都会执行- 推荐使用
&&，效率更高
面试题3：如何不用临时变量交换两个数？
// 方法1：异或
a ^= b; b ^= a; a ^= b;
// 方法2：加减法
a = a + b; b = a - b; a = a - b;
面试题4：5 << 2等于多少？
答案：20。左移n位相当于乘以2的n次方，5 * 2^2 = 20。
十一、总结与预告
本节要点回顾
| 知识点 | 核心内容 |
|---|---|
| 算术运算符 | + - * / %，注意整数除法陷阱 |
| 自增自减 | i++先用后加，++i先加后用 |
| 赋值运算符 | 复合赋值有隐式类型转换 |
| 比较运算符 | 返回boolean，注意==和equals区别 |
| 逻辑运算符 | &&和||有短路特性 |
| 位运算符 | 直接操作二进制位，可用于权限系统 |
| 三元运算符 | 简化if-else选择 |
| 优先级 | 复杂表达式用括号明确顺序 |
🤔 互动问题
int a = 5; int b = a++ + ++a;请问a和b的值分别是多少？- 为什么
0.1 + 0.2 != 0.3？如何正确比较浮点数？ - 位运算在实际开发中有哪些应用场景？
📖 下篇预告
下一篇我们将学习流程控制之条件判断——if-else、switch语句以及Java新版本中的模式匹配特性，让程序能够根据不同条件执行不同的代码分支！
📚 参考资料
💡 学习建议：运算符是编程的基础，建议多做练习，特别是自增自减和位运算部分。理解运算符优先级可以避免很多bug！
汇聚全球AI编程工具，助力开发者即刻编程。
更多推荐
9
0- 0
已为社区贡献51条内容
所有评论(0)