02.运算符

目录

什么是运算符

算术运算符

1.基本四则运算符

2.增量运算符

3.自增/自减运算符

关系运算符

逻辑运算符

&&：逻辑与

||：逻辑或

！：逻辑非

短路求值

位运算符

按位与&：

按位或 |

按位取反~

按位异或^

移位运算

左移<<

右移>>

无符号右移>>>

条件运算符

运算符的优先级

---

什么是运算符

int  a = 10;
int  b = 50;
a-b;
a+b;
a<b;

上述的+和<等都是运算符.

概念：对操作数进行操作时的符号。

不同运算符操作的含义不同。

java中的运算符可分为：算术运算符、关系运算符、逻辑运算符、位运算符、移位运算符以及条件运算符等。

算术运算符

1.基本四则运算符

基本四则运算符有加减乘除模，五种，分别对应（+、-、*、/、%）

int a = 50;
int b = 10;
System.out.println(a + b); // 60
System.out.println(a - b); // 40
System.out.println(a * b); // 500
System.out.println(a / b); // 5
System.out.println(a % b); // 0 --->模运算相当于数学中除法的余数

ps:

• 基本四则运算符都是二元运算符，使用时必须要有左右两个操作数。
• int/int结果还是int类型，并且结果会向下取整。

int a = 3;
int b = 2;
// 在数学中应该是1.5 但是在Java中输出结果为1 会向下取整，即小数点之后全部舍弃掉了
System.out.println(a / b);
// 如果要得到数学中的结果，可以用double类型来接收
double d = a / b;
System.out.println(d);

• 做除法和取模时，右操作数不能为0

int a = 1;
int b = 0;
System.out.println(a / b)
// 运行结果
Exception in thread "main" java.lang.ArithmeticException: / by zero
at Test.main(Test.java:5)

• %不仅可以对整形取模，也可以对double类型取模，但对double类型取模并没有什么意义

System.out.println(11.5 % 2.0);
// 运行结果
1.5

• 两侧操作数的类型不一致时，会向类型大的进行提升

System.out.println(1+0.2); // +的左侧是int，右侧是double，在加之前int被提升为double
// 故：输出1.2
int a = 1;
a += 2; // 相当于 a = a + 2
System.out.println(a); // 输出3
a -= 1; // 相当于 a = a - 1
System.out.println(a); // 输出2
a *= 3; // 相当于 a = a * 3
System.out.println(a); // 输出6
a /= 3; // 相当于 a = a / 3

2.增量运算符

增量运算符包括：+=、-=、*=、%=四种。

增量运算符操作完成后，会将操纵的结果赋值给左边的操作数。

int a = 1;
a += 2; // 相当于 a = a + 2
System.out.println(a); // 输出3
a -= 1; // 相当于 a = a - 1
System.out.println(a); // 输出2
a *= 3; // 相当于 a = a * 3
System.out.println(a); // 输出6
a /= 3; // 相当于 a = a / 3
System.out.println(a); // 输出2
a %= 3; // 相当于 a = a % 2
System.out.println(a); // 输出2

ps：

只有变量才能使用该运算符，常量不可以

3.自增/自减运算符

++是给变量的值加1，--是给变量的值减1。

• 前置++和后置++如果是单独使用，那么没有任何区别。
• 如果混合使用，前置++会先加1，然后使用变量+1之后的值，而后置++会先使用变量原本的值，再进行+1操作。
• 与增量运算符一样，只有变量才能使用自增/自减运算法，常量不能使用，这是因为常量不能被修改。

int a = 1;
a++; // 后置++ 表示给a的值加1，此时a的值为2
System.out.println(a++); // 注意：后置++是先使用变量原来值，表示式结束时给变量+1，因此输出2
System.out.println(a); // 输出3
++a; // 前置++ 表示给a的值加1
System.out.println(++a); // 注意：前置++是先给变量+1，然后使用变量中的值，因此输出5
System.out.println(a); // 输出5
// --操作符给操作-1，与++含义类似

关系运算符

关系运算符主要有：==、!= 、< 、>、<= 、>=。

int a = 10;
int b = 20;
// 注意：在Java中 = 表示赋值，要与数学中的含义区分
// 在Java中 == 表示相等
System.out.println(a == b); // false
System.out.println(a != b); // true
System.out.println(a < b); // true
System.out.println(a > b); // false
System.out.println(a <= b); // true
System.out.println(a >= b); // false

关系运算符的计算结果往往是true或者false。

ps：

当需要多次判断，如计算a大于4但是小于7时，不能连着写，也就是不能写成4<a<7。

逻辑运算符

逻辑运算符主要有三个，分别为：&& 、||、！。

逻辑运算符的计算结果都是boolean类型，也就是说，其结果不是true就是false。

&&：逻辑与

其语法规则为：表达式1&&表达式2。

同时，左右两个表达式必须是boolean类型的结果才行。

逻辑与，相当于我们常用的“且”字。

只有当左右两个表达式都为真时，结果才是真的。

只要有一个表达式为假，结果就为假。

int a = 1;
int b = 2;
System.out.println(a == 1 && b == 2); // 左为真 且 右为真 则结果为真
System.out.println(a == 1 && b > 100); // 左为真 但 右为假 则结果为假
System.out.println(a > 100 && b == 2); // 左为假 但 右为真 则结果为假
System.out.println(a > 100 && b > 100); // 左为假 且 右为假 则结果为假
int a = 1;
int b = 2;
System.out.println(a == 1 || b == 2); // 左为真 且 右为真 则结果为真
System.out.println(a == 1 || b > 100); // 左为真 但 右为假 则结果也为真
System.out.println(a > 100 || b == 2); // 左为假 但 右为真 则结果也为真
System.out.println(a > 100 || b > 100); // 左为假 且 右为假 则结果为假

||：逻辑或

其语法规则与逻辑与一样，都是：表达式1||表达式2，同时，其左右表达式也必须为boolean类型的结果。

逻辑或相当于我们常用的“或”字。

只要有一个表达式为真，那么结果就为真。

只有当两个表达式都为假时，结果才为假。

int a = 1;
int b = 2;
System.out.println(a == 1 || b == 2); // 左为真 且 右为真 则结果为真
System.out.println(a == 1 || b > 100); // 左为真 但 右为假 则结果也为真
System.out.println(a > 100 || b == 2); // 左为假 但 右为真 则结果也为真
System.out.println(a > 100 || b > 100); // 左为假 且 右为假 则结果为假

！：逻辑非

语法规则：！表达式

逻辑非的结果是：真变假，假变真。

也就是说，当我们的表达式为真时，！表达式的结果为假。

当我们的表达式为假时，！表达式的结果为真。

int a = 1;
System.out.println(!(a == 1)); // a == 1 为true，取个非就是false
System.out.println(!(a != 1)); // a != 1 为false，取个非就是true

短路求值

&&与||都要遵守短路求值的规则。

System.out.println(10 > 20 && 10 / 0 == 0); // 打印 false
System.out.println(10 < 20 || 10 / 0 == 0); // 打印 true

根据我们之前学习的知识，当计算10/0时，程序会抛出异常，但上面这两个代码却能正常运行，这说明10/0这里并没有被真正求值。

对于&&，如果左侧表达式值为false，则表达式结果一定是false，无需计算右侧表达式。

对于||，如果左侧表达式值为true，则表达式结果一定是true，无需计算右侧表达式。

而当&和|的表达式结果为boolean时，也表示逻辑运算，但它们并不支持短路求值。

System.out.println(10 > 20 & 10 / 0 == 0); // 程序抛出异常
System.out.println(10 < 20 | 10 / 0 == 0); // 程序抛出异常

位运算符

我们知道，在Java中数据存储的最小单位是字节，而数据操作的最小单位是比特位。

而每个字节是由8个二进制比特位组成的，多个字节组合在一起，可以表示各种不同的数据。

位运算符主要有四个，分别为：&、|、~、^。

其中，除了~是一元运算符外，其余的都是二元运算符。

而位操作符表示按二进制位运算。

按位与&：

如果两个二进制位都是1，则结果为1，否则结果为0

int a = 10;
int b = 20;
System.out.println(a & b);

按位或 |

如果两个二进制位都是0，则结果为0，否则结果为1

int a = 10;
int b = 20;
System.out.println(a | b);

ps：

当&与|的操作数为整数（int，short，long，byte）的时候，表示按位运算。

当操作数为boolean的时候，表示逻辑运算。

按位取反~

如果该位为0则转为1，如果该位为1则转为0

int a = 0xf;
System.out.printf("%x\n", ~a)

• 0x前缀的数字为十六进制数字，而十六进制可以看成是二进制的简化表示方式。
• 一个十六进制数字对应4个二进制位。
• 0xf表示10进制的15，也就是二进制的1111。
• printf能够格式化输出内容，%x则表示按照十六进制输出。
• \n表示换行符。

按位异或^

如果两个数字的二进制位相同，则结果为0，相异则结果为1.

如果两个数相同，则异或的结果为0.

int a = 0x1;
int b = 0x2;
System.out.printf("%x\n", a ^ b);

移位运算

移位运算符有三个，分别为<<、>>、>>>，三个运算符都是二元运算符，且都是按照二进制比特位来进行运算的。

左移<<

最左侧位不要，最右侧补0

ps：

向左移动，丢弃的是符号位，因此正数左移可能会变成负数。

int a = 0x10;
System.out.printf("%x\n", a << 1);
// 运行结果(注意, 是按十六进制打印的)
20

右移>>

最右侧位不要了，最左侧补符号位（整数补0，负数补1）

int a = 0x10;
System.out.printf("%x\n", a >> 1);
// 运行结果(注意, 是按十六进制打印的)
8
int b = 0xffff0000;
System.out.printf("%x\n", b >> 1);
// 运行结果(注意, 是按十六进制打印的)
ffff8000

无符号右移>>>

最右侧位不要，最左侧补0

int a = 0xffffffff;
System.out.printf("%x\n", a >>> 1);
// 运行结果(注意, 是按十六进制打印的)
7fffffff

注意:

1. 左移 1 位, 相当于原数字 * 2. 左移 N 位, 相当于原数字 * 2 的N次方.
2. 右移 1 位, 相当于原数字 / 2. 右移 N 位, 相当于原数字 / 2 的N次方.
3. 由于计算机计算移位效率高于计算乘除, 当某个代码正好乘除 2 的N次方的时候可以用移位运算代替.
4. 移动负数位或者移位位数过大都没有意义.

条件运算符

条件运算符的表达式为：

表达式1？表达式2：表达式3

当 表达式1 的值为 true 时, 整个表达式的值为 表达式2 的值;

当 表达式1 的值为 false 时, 整个表达式的值为 表达式3 的值.

也是 Java 中唯一的一个 三目运算符, 是条件判断语句的简化写法.

// 求两个整数的最大值
int a = 10;
int b = 20;
int max = a > b ? a : b;

ps：

1. 表达式2与表达式3的结果必须是同类型的，除非它们能发生隐式类型转换。

int a = 10;
int b = 20;
int c = a > b? 1 : 2.0;

1. 表达式不能单独存在，其产生的结果必须要被使用。

int a = 10;
int b = 20;
a > b? a : b; // 报错：Error:(15, 14) java: 不是语句

运算符的优先级

在一条表达式中，各个运算符可以混合起来进行运算，但运算符的优先级不同。

// 求a和b的平均值
int a = 10;
int b = 20;
int c = a + (b - a) >> 1;
System.out.println(c);

在上述代码中，由于+的优先级要高于>>，因此a要先与（b-a）的结果做加法，结果为20.

最后再进行右移，因此结果应为10.

注意：

运算符之间是有优先级的. 具体的规则我们不必记忆. 在可能存在歧义的代码中加上括号即可

// 求a和b的平均值
int a = 10;
int b = 20;
int c = a + ((b - a) >> 1);
System.out.println(c);