Java基础知识三（运算符）
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档
前言
更新第三篇文章，这篇文章讲一下Java的运算符相关的知识，对于Java中所有的运算符的种类和内容做一个总结
在Java编程中，运算符（Operators）是执行特定操作的符号，它们用于操作变量和数据。本文将详细介绍Java中的运算符种类、用法以及其作用。
1. 算术运算符（Arithmetic Operators）
算术运算符用于执行基本的数学运算，如加、减、乘、除等。
| 运算符 | 作用 | 示例 |
|---|---|---|
+ |
加法 | int sum = a + b; |
- |
减法 | int diff = a - b; |
* |
乘法 | int product = a * b; |
/ |
除法 | int quotient = a / b; |
% |
取模 | int remainder = a % b; |
注意：在整数除法中，除法运算/会舍弃小数部分。
例子：
public class ArithmeticOperators {
public static void main(String[] args) {
int a = 10, 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
}
}
介绍一个重点知识
这里重点介绍一下最后一个取模运算符，在后面的学习中会起到关键的作用，在后面的循环和选择中经常会遇见多少一循环的问题，例如下面这种：
取模运算符在循环问题中的应用
在编写循环结构时，取模运算符 % 常用于实现 循环周期 相关的问题。例如，我们可以利用取模运算符让一个序列按照固定周期重复循环。
示例：利用取模运算符实现循环周期
假设我们有一个 星期数组，想要模拟一个 无限循环的星期输出，可以利用 % 运算符让索引值在 0 到 6 之间循环。
public class ModuloLoop {
public static void main(String[] args) {
String[] weekDays = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};
// 模拟连续 10 天的循环
for (int i = 0; i < 10; i++) {
System.out.println("Day " + (i + 1) + ": " + weekDays[i % 7]);
}
}
}
输出结果
Day 1: Sunday
Day 2: Monday
Day 3: Tuesday
Day 4: Wednesday
Day 5: Thursday
Day 6: Friday
Day 7: Saturday
Day 8: Sunday
Day 9: Monday
Day 10: Tuesday
原理讲解
在 weekDays[i % 7] 中：
i的值从0递增，但i % 7的结果始终在 0~6 之间循环。- 例如：
0 % 7 = 0（Sunday）1 % 7 = 1（Monday）...6 % 7 = 6（Saturday）7 % 7 = 0（再次回到 Sunday）
这就相当于实现了 循环周期为 7 的轮回效果。
总结
- 取模运算符
%可用于实现 固定周期循环，确保索引值在限定范围内循环。 - 适用于 周期性问题，如星期循环、数组索引循环、颜色切换、任务轮询等。
- 避免数组越界问题，确保索引始终合法。
2. 赋值运算符（Assignment Operators）
赋值运算符用于将右侧的值赋给左侧变量。
| 运算符 | 作用 | 示例 |
|---|---|---|
= |
赋值 | int a = 10; |
+= |
加后赋值 | a += 5; // 等价于 a = a + 5; |
-= |
减后赋值 | a -= 3; // 等价于 a = a - 3; |
*= |
乘后赋值 | a *= 2; // 等价于 a = a * 2; |
/= |
除后赋值 | a /= 2; // 等价于 a = a / 2; |
%= |
取模后赋值 | a %= 3; // 等价于 a = a % 3; |
例子：
public class AssignmentOperators {
public static void main(String[] args) {
int a = 10;
a += 5; // a = a + 5
System.out.println("a += 5: " + a); // 15
a *= 2; // a = a * 2
System.out.println("a *= 2: " + a); // 30
}
}
这里进一步讲解一下赋值运算符：
Java 赋值运算符（Assignment Operators）详解
在 Java 中，赋值运算符用于 将右侧表达式的值赋给左侧变量，它不仅仅包括基本的 = 赋值操作，还有 复合赋值运算符，用于更高效地进行数学运算并赋值。
1. 赋值运算符 =
基本赋值运算符 = 是最基础的赋值运算符，它用于将 右侧的值赋给左侧变量。
示例：
int a = 10; // 将10赋值给变量a
double b = 5.5; // 将5.5赋值给变量b
注意： 赋值运算符
=只是 赋值，不会进行数学计算。
2. 复合赋值运算符
Java 提供了一系列 复合赋值运算符，它们可以简化数学计算并直接赋值给变量。复合赋值运算符的作用相当于运算后再赋值，但 执行效率更高，因为它减少了额外的存取操作。
2.1 复合赋值运算符列表
| 复合赋值运算符 | 作用 | 等价于 |
|---|---|---|
+= |
加法赋值 | a = a + b |
-= |
减法赋值 | a = a - b |
*= |
乘法赋值 | a = a * b |
/= |
除法赋值 | a = a / b |
%= |
取模赋值 | a = a % b |
&= |
按位与赋值 | a = a & b |
| ` | =` | 按位或赋值 |
^= |
按位异或赋值 | a = a ^ b |
<<= |
左移赋值 | a = a << b |
>>= |
右移赋值 | a = a >> b |
>>>= |
无符号右移赋值 | a = a >>> b |
2.2 复合赋值运算符示例
public class AssignmentOperators {
public static void main(String[] args) {
int x = 10;
x += 5; // 等价于 x = x + 5;
System.out.println("x += 5 -> " + x); // 输出: 15
x -= 3; // 等价于 x = x - 3;
System.out.println("x -= 3 -> " + x); // 输出: 12
x *= 2; // 等价于 x = x * 2;
System.out.println("x *= 2 -> " + x); // 输出: 24
x /= 4; // 等价于 x = x / 4;
System.out.println("x /= 4 -> " + x); // 输出: 6
x %= 5; // 等价于 x = x % 5;
System.out.println("x %= 5 -> " + x); // 输出: 1
}
}
代码解析
x += 5;等价于x = x + 5;x -= 3;等价于x = x - 3;x *= 2;等价于x = x * 2;x /= 4;等价于x = x / 4;x %= 5;等价于x = x % 5;
优势：
- 复合赋值运算符 减少代码量，提高可读性。
- 性能优化：减少了额外的变量存取操作，执行效率更高。
3. 复合赋值运算符的注意事项
3.1 复合赋值运算时会自动执行类型转换
在 Java 中，复合赋值运算符会自动执行隐式类型转换，不会改变变量的类型，但可能会截断数据。
示例：
public class TypeCasting {
public static void main(String[] args) {
byte a = 10;
a += 200; // 等价于 a = (byte) (a + 200);
System.out.println("a = " + a); // 输出: -46 (数据溢出)
}
}
解释：
byte a = 10;变量a是byte类型，占 1 个字节（范围-128~127）。a += 200;实际执行的是a = (byte) (a + 200);，但a + 200 = 210超出了byte的范围，所以发生溢出，导致a = -46。
✅ 隐式转换避免了强制类型转换，但需要注意数据溢出问题。
3.2 复合赋值运算符优先级
在 Java 中，赋值运算符的优先级最低，也就是说在表达式中，会优先执行其他运算符，然后再进行赋值。
示例
int a = 2;
int b = 3;
int c = 4;
a += b * c; // 先计算 b * c = 12, 然后 a = a + 12 = 14
System.out.println(a); // 输出: 14
分析：
a += b * c;相当于a = a + (b * c);- 先计算
b * c，再进行a +计算，最后赋值。
4.总结
| 赋值运算符 | 作用 | 示例 |
|---|---|---|
= |
直接赋值 | a = 10; |
+= |
加法赋值 | a += 5; (等价于 a = a + 5;) |
-= |
减法赋值 | a -= 3; (等价于 a = a - 3;) |
*= |
乘法赋值 | a *= 2; (等价于 a = a * 2;) |
/= |
除法赋值 | a /= 4; (等价于 a = a / 4;) |
%= |
取模赋值 | a %= 5; (等价于 a = a % 5;) |
✅ 复合赋值运算符的优势：
- 代码更简洁。
- 执行效率更高。
- 自动进行类型转换（但需注意溢出问题）。
在 Java 中，赋值运算符优先级最低，不能用于链式赋值，不会返回值，这是与 C/C++、JavaScript 的主要区别之一。
3. 关系运算符（Relational Operators）
关系运算符用于比较两个变量或值，结果为true或false。
| 运算符 | 作用 | 示例 |
|---|---|---|
== |
等于 | a == b |
!= |
不等于 | a != b |
> |
大于 | a > b |
< |
小于 | a < b |
>= |
大于等于 | a >= b |
<= |
小于等于 | a <= b |
例子：
public class RelationalOperators {
public static void main(String[] args) {
int a = 10, b = 20;
System.out.println(a > b); // false
System.out.println(a < b); // true
System.out.println(a == 10); // true
System.out.println(a != b); // true
}
}
解释：其中的不等于可以用作为双重否定句的时候使用
4. 逻辑运算符（Logical Operators）
逻辑运算符用于进行逻辑运算，通常用于boolean类型。
| 运算符 | 作用 | 示例 | ||||
|---|---|---|---|---|---|---|
&& |
逻辑与 | (a > 5 && b < 10) |
||||
| || | 逻辑或 | |||||
! |
逻辑非 | !(a > 5) |
注意：&&和||是短路运算符，如果左侧表达式已经可以确定结果，则不会计算右侧表达式。
例子：
public class LogicalOperators {
public static void main(String[] args) {
boolean x = true, y = false;
System.out.println(x && y); // false
System.out.println(x || y); // true
System.out.println(!x); // false
}
}
这里讲解一下有关于短路的代码片段，什么叫短路呢，和物理上的短路不一样但是又有相似的地方，如果在执行代码的时候没有执行某一部分代码就得出了结果就是短路代码
例子：
public class ShortCircuitOrExample {
public static void main(String[] args) {
int a = 10;
if (a < 100 || check()) {
System.out.println("条件满足，执行代码");
}
}
public static boolean check() {
System.out.println("check() 方法被执行！");
return true;
}
}
5. 位运算符（Bitwise Operators）（有一些运算符在编辑成表格的时候有些乱码了，大家体谅）
位运算符用于二进制位操作。
| 运算符 | 作用 | 示例 | ||
|---|---|---|---|---|
& |
按位与 | a & b |
||
| | | 按位或 | a | b | ||
^ |
按位异或 | a ^ b |
||
~ |
按位取反 | ~a |
||
<< |
左移 | a << 2 |
||
>> |
右移 | a >> 2 |
||
>>> |
无符号右移 | a >>> 2 |
6. 条件（三目）运算符（Ternary Operator）
条件运算符是一种简化的if-else表达式。
语法：
变量 = (条件) ? 表达式1 : 表达式2;
示例：
int a = 10, b = 20;
int min = (a < b) ? a : b;
System.out.println("最小值: " + min);
这个运算符在使用的时候，经常比选择语句更有优先级，因为比较简便
7. 增量与减量运算符（Increment and Decrement Operators）
这些运算符用于对变量进行自增或自减。
| 运算符 | 作用 | 示例 |
|---|---|---|
++ |
自增 | a++ 或 ++a |
-- |
自减 | a-- 或 --a |
区别：
++a（前置递增）：先自增，再使用。a++（后置递增）：先使用，再自增。
示例：
int a = 5;
System.out.println(++a); // 输出6
System.out.println(a++); // 输出6, 但a变为7
对增减运算符的解释
前置递增与后置递增运算符详解
1. 概述
在C、C++、Java等编程语言中，++（递增运算符）用于使变量的值加1。根据运算符的位置不同，可以分为前置递增（++i）和后置递增（i++）。
这两者虽然都能让变量自增，但在某些情况下，使用方式不同，尤其是在表达式中。
2. 前置递增（++i）
特点： 先自增，后使用。
解释： 变量i的值先增加1，然后再进行表达式计算。
示例代码：
#include
using namespace std;
int main() {
int a = 5;
int b = ++a; // 先自增 a=6，然后 b 赋值为 6
cout << "a=" << a << ", b=" << b << endl;
return 0;
}
输出结果：
a=6, b=6
3. 后置递增（i++）
特点： 先使用，后自增。
解释： 变量i的当前值先用于表达式计算，随后变量自身才加1。
示例代码：
#include
using namespace std;
int main() {
int a = 5;
int b = a++; // 先赋值 b=5，然后 a 自增变为 6
cout << "a=" << a << ", b=" << b << endl;
return 0;
}
输出结果：
a=6, b=5
4. 对比总结
| 运算符 | 作用顺序 | 影响 | 适用场景 |
|---|---|---|---|
++i |
先自增，再使用 | 变量先变大 | 适用于需要立即使用自增后的值的情况 |
i++ |
先使用，再自增 | 变量后变大 | 适用于先用变量当前值，然后再自增的情况 |
5. 实际应用场景
5.1 在循环中的使用
在for循环中，递增运算符经常用于控制循环变量：
for (int i = 0; i < 5; ++i) { // 使用前置递增
cout << i << " ";
}
由于++i比i++少一个临时变量，性能略优，推荐在循环中使用++i。
5.2 结合函数调用
当++i或i++作为函数参数时，行为不同：
void show(int x) {
cout << "x=" << x << endl;
}
int main() {
int a = 5;
show(++a); // 传递6，a变成6
a = 5;
show(a++); // 传递5，a变成6
}
输出：
x=6
x=5
6. 总结
++i先自增再使用，i++先使用再自增。++i在某些场景下比i++更高效，尤其在循环中。- 在函数调用、表达式运算中要注意区分两者的不同影响。
8. instanceof 运算符
instanceof用于测试对象是否是某个类的实例。
示例：
String str = "Hello";
System.out.println(str instanceof String); // true
9. 运算符优先级
当表达式包含多个运算符时，运算符的优先级决定了计算顺序。
| 优先级 | 运算符 | ||
|---|---|---|---|
| 最高 | () [] . |
||
| 高 | ++ -- ! ~ instanceof |
||
| 中 | * / % |
||
| 低 | + - |
||
| 更低 | << >> >>> |
||
| 更低 | < <= > >= |
||
| 更低 | == != |
||
| 更低 | & |
||
| 更低 | ^ |
||
| 更低 | ` | ` | |
| 更低 | && |
||
| 更低 | ` | ` | |
| 最低 | ?: = += -= *= /= %= |
结论
Java运算符是Java编程的基础，掌握它们的作用和用法可以让代码更加简洁、高效。在实际开发中，合理使用运算符可以优化性能，提高可读性。希望本文能帮助你更好地理解Java的运算符！
总结
上面的文章大概介绍了Java的运算符的概念以及分类等结构，作为基础知识的运算符在任何一种编程语言中都是很重要的基础结构，希望大家能够有所收获！