Java -------- 运算符

言_初

已于 2023-01-06 21:16:10 修改

阅读量485

点赞数 1

文章标签： linux 运维服务器

于 2022-11-15 21:35:00 首次发布

本文链接：https://blog.csdn.net/m0_71722065/article/details/127569113

版权

什么是运算符：

算术运算符：加减乘除模 ( + - * / % )

关系运算符： == != < > <= >=

1. 左移 << : 最左侧位不要了, 在最右侧补 0.

2. 右移 >>: 最右侧位不要了, 最左侧补符号位(正数补0, 负数补1）

3. 无符号右移 >>>: （无论是正数还是负数）都是最右侧位不要了, 在最左侧补 0.

条件运算符: 表达式1 ? 表达式2 : 表达式3

什么是运算符：

计算机的最基本的用途之一就是执行数学运算，Java中也提供了丰富的运算符来操纵变量。

Java 中运算符可分为以下几类：

算术运算符 ( + - * / % )、关系运算符 ( < > == ) 、逻辑运算符、位运算符、移位运算符以及条件运算符等。

算术运算符：加减乘除模 ( + - * / % )

算数运算符： / （除）

注：(1). int / int 结果还是int类型，而且会向下取整。

(2). 要想除（ / ) 以后可以得到小数，就需要分子和分母至少有一个是小数才可以。

(3). 做除法时，右操作数不能为0。 ---- 1/0会报错。

算数运算符： % （模）

注：(1). 模运算相当于数学中除法的余数。

(2). 做取模运算时，右操作数不能为0。

(3). % 不仅可以对整型取模，也可以对double类型取模。(但是没有意义，一般都是对整型取模的).

算数运算符： + （加）

注：当 + 号两侧操作数类型不一致时，向类型大的提升。

在 + 运算符这里，例如下面代码当中的情况： + 的左侧如果是 int 类型，+ 的右侧是 double 类型，那么在加之前 int 就已经被提升为了 double 类型了。
System.out.println(1+0.2);
 // +的左侧是int，右侧是double，在加之前int被提升为double
 // 故：输出1.2

增量运算符： += -= *= %=

注：该种类型运算符操作完成后，会将操纵的结果赋值给左操作数。

注：只有变量才能使用该运算符，常量不能使用。

增量运算符： +=

( 注：其余的增量运算符都与+=类似，在此就不进行一一的介绍啦！ )

例题： sh=sh+2; 这个里面，因为sh是short类型的，不足4个字节，是2个字节，所以在运算之前被整型提升为4个字节了，然后+2,所以sh+2的结果就是4个字节的int 类型了，这时等号左边的sh还是2个字节的，所以当范围大的类型(int)给范围小的类型(short)赋值时，就报错了。

但是sh+=2; 就是可以的，可以理解为 ------ 帮助我们进行了类型的转换。

自增/自减运算符： ++ --

注：++是给变量的值+1，--是给变量的值-1。

运算符：前置++ 和后置++

前置++ : 例如： ++a

后置++ ：例如： a++

例题： 输出结果是 10 （记住这个结论就可以了，想要理解需要去看Java的汇编)
int i=10;
i=i++;
System.out.println(i);

关系运算符： == != < > <= >=

注：其计算结果是 true 或者 false 。

关系运算符： == != < > <= >=

逻辑运算符: && || !

注：运算结果都是 boolean类型。（true 或者 false)

逻辑与（短路与）： &&

语法规则：表达式1 && 表达式2 ，左右表达式必须是boolean类型的结果。

特点：1.如果表达式1为真，那么就去执行表达式2，如果表达式2也为真，那么整体为真。

2.如果表达式1为假，那么就不会去执行表达式2。

由上面的 / （除）运算符的部分我们可知，1/0是会报错。

如果没有执行到后面的 1/0 就不会报错，如果执行了 1/0 就会报错。

在下面的代码中，我们可以看到 a==2 && (1/0)==1 , a的值是1，

所以a==2是false，false && (表达式）-----> 其结果一定是 false .

逻辑或： ||

语法规则：表达式1 || 表达式2，左右表达式必须是boolean类型的结果。

注：左右表达式中至少有一个为真，则结果为真。

特点：1.如果表达式1为真，就不执行表达式2，整体已经为真(发生了短路了）。

2.如果表达式1为假，就继续执行表达式2，若表达式2为真，则整体就为真，

若表达式2为假，则整体就为假。

逻辑非：！

语法规则： ! 表达式

特点：真变假，假变真。

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 并没有真正被求值(也就是说并没有被真正执行) .
注意 :

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

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

(情况1和情况2就是所谓的短路求值了）

3. 对于& 和 | 如果表达式结果为 boolean 时 , 也表示逻辑运算 . 但与 && || 相比 , 它们不支持短路求值.，也就是说 & 或者 | 的2侧的boolean类型的表达式无论什么情形都会被执行，所以就一定会执行到 10/0 这条语句，所以就一定会报错了。（示例代码如下。）
System.out.println(10 > 20 & 10 / 0 == 0); // 程序抛出异常
System.out.println(10 < 20 | 10 / 0 == 0); // 程序抛出异常

位运算符: & | ~ ^

注：位操作表示 按二进制位运算。

注意 : 当 & 和 | 的操作数为整数 (int, short, long, byte) 的时候 , 表示按位运算 , 当操作数为 boolean 的时候 , 表示逻辑运算.就分别相当于 逻辑与 && 和逻辑或 || ，只不过并不能进行短路求值。
System.out.println(10 > 20 & 10 / 0 == 0); // 程序抛出异常
System.out.println(10 < 20 | 10 / 0 == 0); // 程序抛出异常

位运算符： & （按位与）

当 & 的 2边都是布尔值的时候，它也相当于是逻辑运算(相当于逻辑与 && )。
int a=1; System.out.println( a==2 & (1/0)==1 ); //会报错，这个是按位与 & 操作符，不能进行短路求值，虽然 a==2 是错的，但是还是会继续向下执行，所以就执行到了 (1/0)==1 ，所以就报错了。

按位与 &: 如果两个二进制位都是 1, 则结果为 1, 否则结果为 0.

（只要对应位有 0 ，则结果就为 0 ）。

补充一个有趣的小知识：

这里补充一个我最近学到的有趣的小知识：（关于二进制和十进制转换的快速办法）

对于8位的二进制，有如下图：

在上图中每个方格中填入一个 0 或 1 ，然后把方格中为 1 的对应的方格下面的数字相加，就是这个8位二进制所代表的10进制数字。

位运算符： | （按位或）

注：如果两个二进制位都是 0, 则结果为 0, 否则结果为 1.

(只要对应位上面是1，结果就是1）

位运算符： ^ (按位异或)

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

（相同为 0 ，相异为 1 .)

在按位异或这里再加一个新的知识：（很实用，很神奇）

两个相同的数字异或的结果是 0

位运算符： ~ （按位取反）

注：如果该位为 0 则转为 1, 如果该位为 1 则转为 0 。

注意 :

1. 0x 前缀的数字为十六进制数字 . 十六进制可以看成是二进制的简化表示方式 . 一个十六进制数字对应 4 个二进制位.

2. 0xf 表示 10 进制的 15, 也就是二进制的 1111 .

3. printf 能够格式化输出内容 , %x 表示按照十六进制输出 .

4. \n 表示换行符.

移位运算符: << >> >>>

注：移位运算符都是二元运算符，且都是按照二进制比特位来进行运算的。

1. 左移 << : 最左侧位不要了, 在最右侧补 0.

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

2. 右移 >>: 最右侧位不要了, 最左侧补符号位(正数补0, 负数补1）

3. 无符号右移 >>>: （无论是正数还是负数）都是最右侧位不要了, 在最左侧补 0.

注意 :

1. 左移 1 位 , 相当于原数字 * 2. 左移 N 位 , 相当于原数字 * 2 的 N 次方 .

2. 右移 1 位 , 相当于原数字 / 2. 右移 N 位 , 相当于原数字 / 2 的 N 次方 .

3. 由于计算机计算移位效率高于计算乘除 , 当某个代码正好乘除 2 的 N 次方的时候可以用移位运算代替 .

4. 移动负数位或者移位位数过大都没有意义 .

一些细节：1. 左移一位，对于正数来说是乘法（乘2）；右移一位，对于正数来说是除法（除2）。

2. 右移在左边补的是符号位。左移都是在右边补0。

3. -1就是一个很特殊的例子，-1 右移一位以后还是 -1

(1). 负数的右移：负数右移的话，由于要保持它是负数，所以负数的二进制的左边补1。如果一直右移的话，最后就就变成0xFFFFFFFF 即 -1
例如： -4>>1 为-2 ； -4>>2为-1
(2). 负数的左移：跟正整数左移一样，在右边补0，一直左移的话，最后就是0啦。

例如： -2<<2 为-4 ； -2<<31为0

条件运算符: 表达式1 ? 表达式2 : 表达式3

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

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

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

（放表达式1为真的时候，返回表达式2的结果，否则返回表达式3的结果。）

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

关于条件运算符的一道例题：

（true==true) 为真，所以接下来执行（true==true) ? false : true 这个语句，又因为（true==true) ? false : true 这个语句中的(true==true)为真，所以接下来执行 false 语句，所以最后的输出结果就是false .