【Java SE】初学者花三十分钟就能轻松掌握的运算符讲解

Bertha 。 2023-10-05 23:08 3阅读 0赞

**目录**

1.算数运算符

1.1 基本四则运算符

1.2 增量运算符

1.3 自增运算符

2.关系运算符

3.逻辑运算符（重点）

1.1 逻辑与&&

1.2 逻辑或 ||

1.3 逻辑非 ！

1.4 短路求值

4.位运算符

4.1 按位与 &

4.2 按位或 |

4.3 按位异或 ^

5.移位运算符（了解）

5.1 左移操作符 <<

5.2 右移操作符 >>

5.3 无符号右移 >>>

6.条件运算符

--------------------

## 1.算数运算符 ##

### 1.1 基本四则运算符 ###

> **加减乘除模（+ - \* / %）**

public static void main(String[] args) {
            System.out.println(6/4);
            System.out.println(6.0/4);
            System.out.println(6/4.0);
            System.out.println((float)6/4);
            System.out.println(6/(float)4);
            System.out.println((float)(5/2));
        }

代码结果：

![4a2678ffe8c54c78a88a502842654639.png][]

只要有一个操作数是小数，计算的结果就是小数。

public static void main(String[] args) {
            System.out.println(5%2);
            System.out.println(-5%2);
            System.out.println(5%-2);
            System.out.println(-5%-2);
       }

代码结果：

![1ec3e172245844608ca33f85be52f7fd.png][]

public static void main(String[] args) {
            System.out.println(12.5 % 12.5);
            System.out.println(12.2 % 10.5);
     }

代码结果：

![a4b67966168847f889684b81e8a56a80.png][]

**注意**：**在 Java 中%两端的操作数可以是小数。**

因为加减和乘比较简单，就不一一举例子了。

### 1.2 增量运算符 ###

> \+= -= \*= %=

public static void main(String[] args) {
            int a = 100;
            //a = a + 100;
            a += 100;
            System.out.println(a);
     }

表达式a = a + 100；和表达式a += 100含义相同。

代码结果：

![c4ffdfdaebee40ba91080453069c48dc.png][]

![46337a61e1634410bd11311055fa3f9b.png][]

double比int大，这里放不下，要强制类型转换

public static void main(String[] args) {
            double a = 12.5;
            int b = 1;
            b = (int)(b + a);
            System.out.println(b);
     }

如果这里使用 += 就可以自动强制类型转换

public static void main(String[] args) {
            double a = 12.5;
            int b = 1;
            b += a;
            System.out.println(b);
     }

代码结果：

![ff9ca103e4ff44809e9d995427b08107.png][]

其他的增量运算符和 += 一样，就不做介绍了，可以对比+=。

### 1.3 自增运算符 ###

> \++ --

public static void main(String[] args) {
            int k = 100;
            int n = 100;
            System.out.println(k--);
            System.out.println(--n);
     }

代码结果：

![3d5260bec13c4ee8999a62b190cd4860.png][]

\++ 于-- 一样。只是做了加法运算。

**注意：**

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

## 2.关系运算符 ##

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

public static void main(String[] args) {
            int n = 10;
            int k = 11;
            System.out.println(n == k);
            System.out.println(n != k);
            System.out.println(n > k);
            System.out.println(n < k);
            System.out.println(n >= k);
            System.out.println(n <= k);
      }

代码结果：

![3f959ea799be4b15980ce3ff59d54971.png][]

![449a106f85664820a5cf16cb35942464.png][]

可以看到代码有错误。

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

## 3.逻辑运算符（重点） ##

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

### 1.1 逻辑与&& ###

语法规则：表达式1 && 表达式2，左右表达式必须是boolean类型的结果。  
相当于现实生活中的且，比如：如果是学生，并且 带有学生证 才可以享受半票。  
两个表达式都为真，结果才是真，只要有一个是假，结果就是假。

![8332c6c66b97481291d9c8d2dfb5307a.png][]

public static void main(String[] args) {
            int a = 10;
            int b = 100;
            System.out.println(a < 100 && b > 100);
            System.out.println(a < 100 && b == 100);
            System.out.println(a < 10 && b >= 10);
            System.out.println(a == 10 && b > 10);
     }

代码结果：

![5953f9f8ae9f4b82b3ec9accea36bbf8.png][]

### 1.2 逻辑或 || ###

语法规则：表达式1 || 表达式2，左右表达式必须是boolean类型的结果。  
相当于现实生活中的或，比如：买房子交钱时，全款 或者 按揭都可以，如果全款或者按揭，房子都是你的，否则站一边去。

![681d40366bf44fb9b78c6370e31c033e.png][]

public static void main(String[] args) {
            int n = 1;
            int k = 2;
            System.out.println(n > 10 || k > 10);
            System.out.println(n < 10 || k < 10);
            System.out.println(n > 10 || k < 10);
            System.out.println(n == 10 || k > 10);
     }

代码结果：

![d6a931a4ede24874a395f4d075951795.png][]

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

### 1.3 逻辑非 ！ ###

语法规则：! 表达式  
真变假，假变真。

![b583447c7f064712a5cf5871e6dfe683.png][]

public static void main(String[] args) {
            int n = 10;
            System.out.println(!(n > 1));
            System.out.println(!(n == 1));
    }

代码结果：

![85150476f80c4a3382980d7a957bc816.png][]

### 1.4 短路求值 ###

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

public static void main(String[] args) {
            int n = 100;
            int k = 10;
            //&&左边值为false，不用计算右边，表达式的结果为false
            System.out.println(n < k && k / 0 == 0);
            //&&左边值为true，不用计算右边，表达式的结果为true
            System.out.println(n > k || k / 0 == 0);
    }

代码结果：

![ed432ffa219f4a5c94f644679e728fed.png][]

我们都知道, 计算 10 / 0 会导致程序抛出异常. 但是上面的代码却能正常运行, 说明 10 / 0 并没有真正被求值。

**注意:**

1.  对于 && , 如果左侧表达式值为 false, 则表达式结果一定是 false, 无需计算右侧表达式.
2.  对于 ||, 如果左侧表达式值为 true, 则表达式结果一定是 true, 无需计算右侧表达式.
3.  & 和 | 如果表达式结果为 boolean 时, 也表示逻辑运算. 但与 && || 相比, 它们不支持短路求值.

## 4.位运算符 ##

位运算符的使用和C语言是一样的，C是如何使用的，Java 就如何使用。

> 按位与（&）
> 
> 按位或（|）
> 
> 按位异或（^）
> 
> 注：操作数必须是整数
> 
>  比较的是操作数的二进制序列

### 4.1 按位与 & ###

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text][]![15995b3703764b22b373d54890336e43.png][]

public static void main(String[] args) {
        int a = 3;
        int b = 5;
        System.out.println(a & b);
    }

代码结果：

![87ad2a8051974ed392abca3236f2c4fb.png][]

### 4.2 按位或 | ###

![0733589b8be44bea9d92df4528a61640.png][]

public static void main(String[] args) {
            int a = 3;
            int b = 5;
            System.out.println(a | b);
     }

代码结果：

![568c61a79a974cd6af88dbb140f29732.png][]

### 4.3 按位异或 ^ ###

![06a1139ca3f841f09cd0ce4090b8d48d.png][]

public static void main(String[] args) {
            int a = 3;
            int b = 5;
            System.out.println(a ^ b);
    }

代码结果：

![2f51109e420b40d19470a59d927970c0.png][]

## 5.移位运算符（了解） ##

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

### 5.1 左移操作符 << ###

移位规则:

左边舍弃，右边补0.

### ![98516f28bc03499da3fdb9bda9987664.png][] ###

###  ###

### 5.2 右移操作符 >> ###

右边舍弃，如果是正数，左边补0；如果是负数，左边补1.

![827ecf8eddd9475cbe5d5a29ad79ae78.png][]

### 5.3 无符号右移 >>> ###

最右侧位不要了, 最左侧补 0  
![c703f930502849e59e8d61a7be58cbf0.png][]

**注意:**

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

## 6.条件运算符 ##

条件运算符只有一个:  
表达式1 ? 表达式2 : 表达式3

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

public static void main(String[] args) {
            int a = 10;
            int b = 20;
            int max = a > b ? a : b;
            System.out.println(max);
       }

代码结果：

![2183e146567e4ac197a727603aeb4f36.png][]

**注意：**  
1. 表达式2和表达式3的结果要是同类型的，除非能发生类型隐式类型转换

![cf2560be6ba741289a898980d8ff694b.png][]

代码报错

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

![17e3464a4b784991820cdec0b2b93413.png][]

代码报错

[4a2678ffe8c54c78a88a502842654639.png]: https://img-blog.csdnimg.cn/4a2678ffe8c54c78a88a502842654639.png
[1ec3e172245844608ca33f85be52f7fd.png]: https://img-blog.csdnimg.cn/1ec3e172245844608ca33f85be52f7fd.png
[a4b67966168847f889684b81e8a56a80.png]: https://img-blog.csdnimg.cn/a4b67966168847f889684b81e8a56a80.png
[c4ffdfdaebee40ba91080453069c48dc.png]: https://img-blog.csdnimg.cn/c4ffdfdaebee40ba91080453069c48dc.png
[46337a61e1634410bd11311055fa3f9b.png]: https://img-blog.csdnimg.cn/46337a61e1634410bd11311055fa3f9b.png
[ff9ca103e4ff44809e9d995427b08107.png]: https://img-blog.csdnimg.cn/ff9ca103e4ff44809e9d995427b08107.png
[3d5260bec13c4ee8999a62b190cd4860.png]: https://img-blog.csdnimg.cn/3d5260bec13c4ee8999a62b190cd4860.png
[3f959ea799be4b15980ce3ff59d54971.png]: https://img-blog.csdnimg.cn/3f959ea799be4b15980ce3ff59d54971.png
[449a106f85664820a5cf16cb35942464.png]: https://img-blog.csdnimg.cn/449a106f85664820a5cf16cb35942464.png
[8332c6c66b97481291d9c8d2dfb5307a.png]: https://img-blog.csdnimg.cn/8332c6c66b97481291d9c8d2dfb5307a.png
[5953f9f8ae9f4b82b3ec9accea36bbf8.png]: https://img-blog.csdnimg.cn/5953f9f8ae9f4b82b3ec9accea36bbf8.png
[681d40366bf44fb9b78c6370e31c033e.png]: https://img-blog.csdnimg.cn/681d40366bf44fb9b78c6370e31c033e.png
[d6a931a4ede24874a395f4d075951795.png]: https://img-blog.csdnimg.cn/d6a931a4ede24874a395f4d075951795.png
[b583447c7f064712a5cf5871e6dfe683.png]: https://img-blog.csdnimg.cn/b583447c7f064712a5cf5871e6dfe683.png
[85150476f80c4a3382980d7a957bc816.png]: https://img-blog.csdnimg.cn/85150476f80c4a3382980d7a957bc816.png
[ed432ffa219f4a5c94f644679e728fed.png]: https://img-blog.csdnimg.cn/ed432ffa219f4a5c94f644679e728fed.png
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text]: https://img-blog.csdnimg.cn/95ebac1a5abb4185ae2732dcec12e6d6.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_
[15995b3703764b22b373d54890336e43.png]: https://img-blog.csdnimg.cn/15995b3703764b22b373d54890336e43.png
[87ad2a8051974ed392abca3236f2c4fb.png]: https://img-blog.csdnimg.cn/87ad2a8051974ed392abca3236f2c4fb.png
[0733589b8be44bea9d92df4528a61640.png]: https://img-blog.csdnimg.cn/0733589b8be44bea9d92df4528a61640.png
[568c61a79a974cd6af88dbb140f29732.png]: https://img-blog.csdnimg.cn/568c61a79a974cd6af88dbb140f29732.png
[06a1139ca3f841f09cd0ce4090b8d48d.png]: https://img-blog.csdnimg.cn/06a1139ca3f841f09cd0ce4090b8d48d.png
[2f51109e420b40d19470a59d927970c0.png]: https://img-blog.csdnimg.cn/2f51109e420b40d19470a59d927970c0.png
[98516f28bc03499da3fdb9bda9987664.png]: https://img-blog.csdnimg.cn/98516f28bc03499da3fdb9bda9987664.png
[827ecf8eddd9475cbe5d5a29ad79ae78.png]: https://img-blog.csdnimg.cn/827ecf8eddd9475cbe5d5a29ad79ae78.png
[c703f930502849e59e8d61a7be58cbf0.png]: https://img-blog.csdnimg.cn/c703f930502849e59e8d61a7be58cbf0.png
[2183e146567e4ac197a727603aeb4f36.png]: https://img-blog.csdnimg.cn/2183e146567e4ac197a727603aeb4f36.png
[cf2560be6ba741289a898980d8ff694b.png]: https://img-blog.csdnimg.cn/cf2560be6ba741289a898980d8ff694b.png
[17e3464a4b784991820cdec0b2b93413.png]: https://img-blog.csdnimg.cn/17e3464a4b784991820cdec0b2b93413.png