【JavaSE】运算符

目录

1、算数运算符

1、基本四则运算：加减乘除模（+ - * / %）

2、增量运算符（+=  -=  *=  %=）  

 3、自增/自减运算符（++  --）

2、关系运算符

 3、逻辑运算符（重点）

3.1、逻辑与（&&）

3.2、逻辑或 （ || ）

 3.3、逻辑非 ！

3.4、短路求值

 4、位运算符

 4.1、按位与 &

4.2、按位或 | 

4.3、按位取反 （~）

4.4、按位异或（^）

 5、位移运算符

5.1、左移（<<）

5.2、右移  (>>) 

5.3、无符号右移 （>>>）

6、条件运算符

 7、运算符的优先级

---

1、算数运算符

1、基本四则运算：加减乘除模（+ - * / %）

int a = 20;
int b = 10;
System.out.println(a + b); // 30
System.out.println(a - b); // 10
System.out.println(a * b); // 200
System.out.println(a / b); // 2
System.out.println(a % b); // 0 --->模运算相当于数学中除法的余数

 注意：

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

int a = 3;
int b = 2;


//在数学种应该是1.5，但是在Java中输出结果为1，会向下取整，即小数点之后全部丢弃
System.out.println(a/b);

//如果要得到数学中的结果，可以使用如下方式
double d = a * 1.0 / b;
System.out.println(d);

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

int a = 1;
int b = 0;
System.out.println(a / b)

运行结果为：

•  % 不仅可以对整数取模，也可以对double类型取模，但是没有意义，一般都是对整型取模的

 

•  两个操作数类型不一致时，向类型大的提升

 四则运算大家在C语言中都了解过、那么在这里分别用除法（/）和取模（%）来举例，来看下边的几个代码结果是：

1、代码一

public class Test {
    public static void main(String[] args) {
        System.out.println(5/2);
        System.out.println((float)5/2);
        System.out.println(5/(float)2);
        System.out.println((float)(5/2));
    }

结果为：

 结果为什么是这些呢？

1、第一个输出结果：5和2都是整数，向下取整，结果为2

2、第二个输出结果：float是给5进行了强转，得到 5.0 / 2，输出结果为2.5

3、第三个输出结果：float给2进行了强转，得到 5 / 2.0，输出结果为2.5

4、第四个输出结果：float给(5 / 2)整体进行了强转，将结果转换为float类型，输出结果为2.0

2、代码二

public class Test {
    public static void main(String[] args) {
        System.out.println(10 % 3);
        System.out.println(10 % -3);
        System.out.println(-10 % 3);
        System.out.println(-10 % -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

特别注意：一些代码中的小错误

 可以这样修改：

 注意：

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

---

 3、自增/自减运算符（++  --）

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

前置 ++ （++a）	后置 ++ （a++）
先计算，后赋值	先赋值，后计算

 举例：

 注意：

• 如果单独使用，【前置++】和【后置++】没有任何区别
• 如果混合使用，【前置++】先+1，然后使用变量+1之后的值，【后置++】先使用变量原来的值，表达式结束时给变量+1
• 只有变量才能使用自增/自减运算符，常量不能使用，因为常量不允许被修改

---

2、关系运算符

关系运算符主要有六个：==   !=   <    >     <=      >=，起计算结果是 true 或者 false。

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

注意：当需要多次判断时，不能连着写，比如：3 < a <5，Java程序与数学中是有区别的。

---

 3、逻辑运算符（重点）

逻辑运算符主要有三个：&&   ||   ！，运算结果都是boolean类型。

3.1、逻辑与（&&）

语法规则：

布尔表达式1  &&  布尔表达式2， 左右表达式必须是boolean类型的结果。

那么就只有两个取值，true 和 false。

表达式1	表达式2	结果
真	真	真
真	假	假
假	真	假
假	假	假

总结：

• 逻辑与有假则为假，全真这位真
• 表达式1为真，继续执行表达式2；
• 表达式1为假， 那么就不会在执行表达式2

        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); // 左为假 且 右为假 则结果为假
    }
}

---

3.2、逻辑或 （ || ）

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

表达式1	表达式2	结果
真	真	真
真	假	真
假	真	真
假	假	假

总结：

• 有真则为真，全假则为假
• 表达式1判断完为假，会继续判断表达式2
• 表达式1判断完为真，不会再判断表达式2

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); // 左为假 且 右为假 则结果为假

---

 3.3、逻辑非 ！

语法规则： ！表达式

真变假，假变真。

表达式	！表达式
真	假
假	真

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

---

3.4、短路求值

&& 和 || 遵循短路求值的规则

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时，也表示逻辑运算，但是 && 和 || 相比，他们不支持短路求值。

---

 4、位运算符

Java 中数据存储的最小单位是字节，而数据操作的最小单位是比特位. 字节是最小的存储单位，每个字节是由8个二进制比特位组成的，多个字节组合在一起可以表示各种不同的数据。

位运算符主要有四个： &  |   ~   ^ ，除 ~ 是一元运算符外，其余都是二元运算符。

位操作表示 按二进制位运算. 计算机中都是使用二进制来表示数据的(01构成的序列), 按位运算就是在按照二进制位的每一位依次进行计算.

 4.1、按位与 &

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

进行按位运算，需要先把 10 和 20 转成二进制，分别为 1010 和 10100

 

提示：可以与逻辑与（&&）对应着来记忆 ，两个全为真（1），结果就为（1），两个中有一个为假（0），结果就为假（0）.

---

4.2、按位或 | 

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

 运算方式和按位与类似

 提示：可以与逻辑或（|）对应来记忆，两个中只要有一个为真（1），结果就为真（1）

注意：

当 & 和 | 的操作数为整数（int 、short 、long、byte）的时候，表示按位运算，当操作数为 boolean 的时候，表示逻辑运算 

---

4.3、按位取反 （~）

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

这里看一个奇怪的现象

 这里进行解释：

以byte类型为例

在内存中数据是以二进制补码的形式存储的。

正数  ：  原码=反码= 补码

负数  ：  补码 = 原码取反+1

将10以二进制的形式存储在内存中为：0000 1010

 （~10）计算步骤如下：

第一步：将10的补码取反：11110101     这里还是补码

第二步：要输出原码，首先对补码减1，11110101 -1，得到反码11110100

第三步：反码取反得到原码：10001011——————>-11

---

4.4、按位异或（^）

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

 

---

 5、位移运算符

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

5.1、左移（<<）

最左侧位丢弃，最右边补0

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

---

5.2、右移  (>>) 

最右侧位丢弃，补符号位（正数补0 ，负数补1）

---

5.3、无符号右移 （>>>）

最右侧丢弃，最左侧补0

 注意：

• 由于计算机计算位移效率高于计算乘除，当某个代码正好乘除2^n时，可以使用位移运算代替。
• 移动负数位或者位移位数过大都没有意义

---

6、条件运算符

布尔表达式1 ? 表达式2 : 表达式3

布尔表达式1	表达式2	表达式3
true	√
false		√

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

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

这里了解一个典型的例题 

注意：

1、表达式2 和 表达式3 的结果要是同类型的、除非能发生类型隐式类型转换

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

 2、表达式不能单独存在，其产生的结果必须要被接收

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

//修改，条件运算符结果为数值，所以要用变量来接收这个值
int ret = a > b ? a : b;

---

 7、运算符的优先级

在一条表达式中，各个运算符可以混合起来进行运算，但是运算符的优先级不同，比如：* 和 / 的优先级要高于 +和 - ，有些情况下稍不注意，可能就会造成很大的麻烦。

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

 上述表达式中，由于 + 的优先级要高于 >> , 因此a先和b-a的结果做加法，整体为20，最后再进行右移，因此结果为10。

注意：

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