目录
一. 简介
在 Java 中，运算符用于对数据进行各种运算操作。以下是一些常见的 Java 运算符：
-
算术运算符：
+：加法-：减法*：乘法/：除法%：取余（模运算）
-
自增自减运算符：
++：自增，使变量的值增加 1--：自减，使变量的值减少 1
-
关系运算符：
==：等于!=：不等于>：大于<：小于>=：大于等于<=：小于等于
-
逻辑运算符：
&&：逻辑与||：逻辑或!：逻辑非
-
位运算符：
&：按位与|：按位或^：按位异或~：按位取反<<：左移>>：右移>>>：无符号右移
-
赋值运算符：
=：简单赋值+=：加等于-=：减等于*=：乘等于/=：除等于%=：取余等于
-
条件运算符（三元运算符）：
condition? expression1 : expression2：如果条件为真，返回表达式 1 的值；否则，返回表达式 2 的值
运算符在 Java 编程中用于执行各种计算和逻辑判断，以实现程序的功能。
二. 算术运算符
Java 中的算术运算符用于执行基本的数学运算。以下是对常见算术运算符的详细解释：
-
+（加法运算符）- 用于将两个数相加。
- 示例：
int sum = 5 + 3;结果sum的值为 8 。
-
-（减法运算符）- 用于从一个数中减去另一个数。
- 示例：
int difference = 8 - 2;结果difference的值为 6 。
-
*（乘法运算符）- 用于两个数相乘。
- 示例：
int product = 4 * 5;结果product的值为 20 。
-
/（除法运算符）- 用于执行除法运算。
- 当操作数都是整数时，结果为整数部分（向下取整）。
- 示例：
int quotient = 7 / 2;结果quotient的值为 3 。 - 如果操作数中有一个是浮点数，结果为浮点数。
- 示例：
double quotient = 7.0 / 2;结果quotient的值为 3.5 。
-
%（取模运算符，也称为取余运算符）- 用于计算除法运算的余数。
- 示例：
int remainder = 7 % 3;结果remainder的值为 1 。
在进行算术运算时，需要注意数据类型的范围，以避免溢出。例如，两个较大的整数相加可能会超过 int 类型的取值范围。
以下是一个示例代码，展示了算术运算符的使用：
public class ArithmeticOperatorsExample {
public static void main(String[] args) {
int num1 = 10;
int num2 = 3;
int addition = num1 + num2;
int subtraction = num1 - num2;
int multiplication = num1 * num2;
int division = num1 / num2;
int modulus = num1 % num2;
System.out.println("加法: " + addition);
System.out.println("减法: " + subtraction);
System.out.println("乘法: " + multiplication);
System.out.println("除法: " + division);
System.out.println("取模: " + modulus);
}
}
二. 自加,自减
在 Java 中，++（自增运算符）和 --（自减运算符）用于对变量的值进行增加或减少 1 的操作。
++ 自增运算符
有两种使用方式：前缀形式 ++i 和后缀形式 i++ 。
- 前缀形式
++i：先将变量的值增加 1，然后再使用变量的值进行其他操作。
int i = 5;
int result = ++i; // 先将 i 的值增加到 6，然后将 6 赋值给 result
- 后缀形式
i++：先使用变量的值进行其他操作，然后再将变量的值增加 1 。
int i = 5;
int result = i++; // 先将 5 赋值给 result，然后将 i 的值增加到 6
-- 自减运算符
与自增运算符类似，也有前缀形式 --i 和后缀形式 i-- 。
- 前缀形式
--i：先将变量的值减少 1，然后再使用变量的值。 - 后缀形式
i--：先使用变量的值，然后再将变量的值减少 1 。
以下是一个示例代码，展示了自增和自减运算符的使用：
public class IncrementDecrementExample {
public static void main(String[] args) {
int num1 = 5;
int num2 = 5;
int result1 = ++num1; // num1 先自增为 6，然后赋值给 result1
int result2 = num2++; // num2 先赋值给 result2 为 5，然后自增为 6
System.out.println("result1: " + result1); // 输出 6
System.out.println("num1: " + num1); // 输出 6
System.out.println("result2: " + result2); // 输出 5
System.out.println("num2: " + num2); // 输出 6
}
}
需要注意的是，在复杂的表达式中使用自增和自减运算符时，要特别小心其运算顺序和结果，以避免出现意外的错误。
三. 算术赋值运算符
在 Java 中，算术赋值运算符是将算术运算和赋值操作组合在一起的运算符。它们包括 += 、 -= 、 *= 、 /= 和 %= 。
+=（加赋值运算符）- 示例：
a += b等价于a = a + b - 例如:
- 示例：
int a = 5;
int b = 3;
a += b; // a 的值变为 8
-=（减赋值运算符）- 示例：
a -= b等价于a = a - b - 例如：
- 示例：
int a = 10;
int b = 4;
a -= b; // a 的值变为 6
*=（乘赋值运算符）- 示例：
a *= b等价于a = a * b - 例如：
- 示例：
int a = 2;
int b = 5;
a *= b; // a 的值变为 10
/=（除赋值运算符）- 示例：
a /= b等价于a = a / b - 例如:
- 示例：
int a = 15;
int b = 3;
a /= b; // a 的值变为 5
%=（取模赋值运算符）- 示例：
a %= b等价于a = a % b - 例如：
- 示例：
int a = 17;
int b = 4;
a %= b; // a 的值变为 1
使用算术赋值运算符可以使代码更简洁，特别是在对一个变量进行反复的算术运算和赋值操作时。
四. 关系运算符
在 Java 中，关系运算符用于比较两个值之间的关系，并返回一个布尔值（true 或 false）。以下是常见的关系运算符：
==（等于）
- 用于比较两个值是否相等。
- 示例：
5 == 5返回true，5 == 6返回false。
!=（不等于）
- 用于判断两个值是否不相等。
- 示例：
5!= 6返回true，5!= 5返回false。
>（大于）
- 检查左边的值是否大于右边的值。
- 示例：
6 > 5返回true，5 > 6返回false。
<（小于）
- 检查左边的值是否小于右边的值。
- 示例：
5 < 6返回true，6 < 5返回false。
>=（大于等于）
- 左边的值大于或等于右边的值时返回
true。- 示例：
6 >= 5和5 >= 5都返回true，4 >= 5返回false。
<=（小于等于）
- 左边的值小于或等于右边的值时返回
true。- 示例：
5 <= 6和5 <= 5都返回true，6 <= 5返回false。
需要注意的是，关系运算符不仅可以用于基本数据类型（如整数、浮点数、字符等）的比较，也可以用于对象的比较（但通常需要重写对象的 equals 方法来实现自定义的比较逻辑）。
以下是一个使用关系运算符的示例代码：
public class RelationshipOperatorExample {
public static void main(String[] args) {
int num1 = 10;
int num2 = 20;
boolean isEqual = num1 == num2;
boolean isNotEqual = num1!= num2;
boolean isGreater = num1 > num2;
boolean isLess = num1 < num2;
boolean isGreaterOrEqual = num1 >= num2;
boolean isLessOrEqual = num1 <= num2;
System.out.println("num1 == num2: " + isEqual);
System.out.println("num1!= num2: " + isNotEqual);
System.out.println("num1 > num2: " + isGreater);
System.out.println("num1 < num2: " + isLess);
System.out.println("num1 >= num2: " + isGreaterOrEqual);
System.out.println("num1 <= num2: " + isLessOrEqual);
}
}五. 逻辑运算符
在 Java 中，逻辑运算符用于对布尔值进行操作，以组合或否定条件。常见的逻辑运算符有以下几种：
-
&&（逻辑与）- 当且仅当两个操作数都为
true时，结果才为true。否则，结果为false。 - 示例：
(5 > 3) && (2 < 1)，其中(5 > 3)为true，但(2 < 1)为false，所以整个表达式的结果为false。
- 当且仅当两个操作数都为
-
||（逻辑或）- 只要两个操作数中有一个为
true，结果就为true。只有当两个操作数都为false时，结果才为false。 - 示例：
(5 < 3) || (2 > 1)，因为(2 > 1)为true，所以整个表达式的结果为true。
- 只要两个操作数中有一个为
-
!（逻辑非）- 用于反转操作数的布尔值。如果操作数为
true，则!操作的结果为false；如果操作数为false，则结果为true。 - 示例：
!(5 > 3)，由于(5 > 3)为true，所以!(5 > 3)的结果为false。
- 用于反转操作数的布尔值。如果操作数为
逻辑运算符常用于控制程序的流程，例如在 if 语句、 while 循环等结构中根据条件的真假来决定执行的代码路径。
以下是一个示例代码，展示了逻辑运算符的使用：
public class LogicalOperatorExample {
public static void main(String[] args) {
boolean condition1 = true;
boolean condition2 = false;
// 逻辑与
boolean andResult = condition1 && condition2;
System.out.println("逻辑与结果: " + andResult); // 输出 false
// 逻辑或
boolean orResult = condition1 || condition2;
System.out.println("逻辑或结果: " + orResult); // 输出 true
// 逻辑非
boolean notResult =!condition1;
System.out.println("逻辑非结果: " + notResult); // 输出 false
}
}
六. 位运算符
在 Java 中，位运算符用于对整数类型（byte、short、int 和 long）的位进行操作。以下是常见的位运算符：
-
&（按位与）- 对两个操作数的对应位进行与操作。只有当两个对应位都为 1 时，结果位才为 1 ，否则为 0 。
- 示例：
5 & 3，即0101 & 0011，结果为0001，也就是 1 。
-
|（按位或）- 对两个操作数的对应位进行或操作。只要两个对应位中有一个为 1 ，结果位就为 1 。
- 示例：
5 | 3，即0101 | 0011，结果为0111，也就是 7 。
-
^（按位异或）- 对两个操作数的对应位进行异或操作。当两个对应位不同时，结果位为 1 ，相同时为 0 。
- 示例：
5 ^ 3，即0101 ^ 0011，结果为0110，也就是 6 。
-
~（按位取反）- 对操作数的每一位进行取反操作，1 变为 0 ，0 变为 1 。
- 示例：
~5，即~0101，结果为1010，在有符号整数中表示 -6 。
-
<<（左移）- 将操作数的所有位向左移动指定的位数，右边用 0 填充。
- 示例：
5 << 2，即0101 << 2，结果为010100，也就是 20 。
-
>>（右移）- 将操作数的所有位向右移动指定的位数，如果操作数为正数，左边用 0 填充；如果为负数，左边用 1 填充。
- 示例：
5 >> 1，即0101 >> 1，结果为0010，也就是 2 。
-
>>>（无符号右移）- 无论操作数的正负，都用 0 填充左边的空位。
- 示例：
-5 >>> 1，即11111011 >>> 1，结果为01111101。
位运算符在某些特定的编程场景中，如优化性能、处理二进制数据、实现特定的算法等方面非常有用。
public class BitwiseOperatorExample {
public static void main(String[] args) {
int num1 = 5;
int num2 = 3;
System.out.println("num1 & num2 = " + (num1 & num2));
System.out.println("num1 | num2 = " + (num1 | num2));
System.out.println("num1 ^ num2 = " + (num1 ^ num2));
System.out.println("~num1 = " + ~num1);
System.out.println("num1 << 2 = " + (num1 << 2));
System.out.println("num1 >> 1 = " + (num1 >> 1));
System.out.println("num1 >>> 1 = " + (num1 >>> 1));
}
}
七.其他运算符
-
? :（三元运算符）- 语法：
condition? expression1 : expression2 - 如果
condition为true，则返回expression1的值；否则，返回expression2的值。 - 示例：
int num = (5 > 3)? 10 : 20;由于5 > 3为true，所以num的值为10。
- 语法：
-
.（点运算符）- 用于访问对象的属性或方法。
- 示例：
String str = "Hello"; int length = str.length();这里通过.length()访问了String对象str的length方法。
-
new- 用于创建对象或数组。
- 示例：创建对象：
Person person = new Person();创建数组：int[] arr = new int[5];
-
->（在 Java 8 的 lambda 表达式中使用）- 用于指定 lambda 表达式中的参数和主体。
- 示例：
List<String> names = Arrays.asList("Alice", "Bob"); names.forEach(name -> System.out.println(name));
八. 运算优先级
以下是 Java 中运算符优先级的完整列表，从高到低排列：
- 括号
()- 一元运算符：
++、--、+（正号）、-（负号）、~（按位取反）、!（逻辑非）- 乘除与取余：
*、/、%- 加减：
+、-- 移位：
<<、>>、>>>- 关系比较：
<、<=、>、>=、instanceof- 相等比较：
==、!=- 按位与：
&- 按位异或：
^- 按位或：
|- 逻辑与：
&&- 逻辑或：
||- 条件运算符（三元运算符）：
? :- 赋值运算符：
=、+=、-=、*=、/=、%=、<<=、>>=、&=、^=、|=
如果表达式中包含多个具有不同优先级的运算符，将按照优先级从高到低的顺序进行计算。如果优先级相同，则按照从左到右的顺序进行计算。
为了使代码的逻辑更加清晰，避免由于优先级导致的错误，在复杂的表达式中，建议使用括号来明确计算的顺序。
例如：
int a = 2;
int b = 3;
int c = 4;
int result1 = a + b * c; // 先计算 b * c ，结果为 12，然后加上 a ，最终结果为 14
int result2 = (a + b) * c; // 先计算 a + b ，结果为 5，然后乘以 c ，最终结果为 20