【大数据】学习笔记 1 Java SE 第2章 Java基础语法 2.10 运算符(Operator)(掌握)

缺乏、安全感 2024-03-22 10:47 47阅读 0赞

### 【大数据】学习笔记 ###

#### 文章目录 ####

*   *  【大数据】学习笔记
     *   *  1 Java SE
         *   *  第2章 Java基础语法
             *   *  2.10 运算符(Operator)(掌握)
                 *   *  2.10.1 算术运算符
                     *  2.10.2 关系运算符/比较运算符
                     *  2.10.3 逻辑运算符
                     *  2.10.4 条件运算符
                     *  2.10.5 位运算符
                     *  2.10.6 赋值运算符
                     *  2.10.7 运算符优先级

![在这里插入图片描述][ea1d2271f2eb4f6f96a02a7137e903f6.png_pic_center]

#### 1 Java SE ####

##### 第2章 Java基础语法 #####

###### 2.10 运算符(Operator)(掌握) ######

在Java中，一共有38个运算符。

![在这里插入图片描述][f0abea1c43a44522ae36449cb550fd03.png_pic_center]

运算符的分类：

*  按照功能分：算术运算符、赋值运算符、比较运算符、逻辑运算、条件运算符、Lambda运算符

<table> 
 <thead> 
  <tr> 
   <th align="center">分类</th> 
   <th align="center">运算符</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">算术运算符（7个）</td> 
   <td align="center">+、-、*、/、%、++、–</td> 
  </tr> 
  <tr> 
   <td align="center">赋值运算符（12个）</td> 
   <td align="center">=、+=、-=、*=、/=、%=、&gt;&gt;=、&lt;&lt;=、&gt;&gt;&gt;=、&amp;=、|=、^=等</td> 
  </tr> 
  <tr> 
   <td align="center">关系运算符（6个）</td> 
   <td align="center">&gt;、&gt;=、&lt;、&lt;=、==、!=</td> 
  </tr> 
  <tr> 
   <td align="center">逻辑运算符（6个）</td> 
   <td align="center">&amp;、|、^、!、&amp;&amp;、||</td> 
  </tr> 
  <tr> 
   <td align="center">条件运算符（2个）</td> 
   <td align="center">(条件表达式)?结果1:结果2</td> 
  </tr> 
  <tr> 
   <td align="center">位运算符（7个）</td> 
   <td align="center">&amp;、|、^、~、&lt;&lt;、&gt;&gt;、&gt;&gt;&gt;</td> 
  </tr> 
  <tr> 
   <td align="center">Lambda运算符（1个）</td> 
   <td align="center">-&gt;（后面学）</td> 
  </tr> 
 </tbody> 
</table>

*  按照操作数个数分：一元运算符（单目运算符）、二元运算符（双目运算符）、三元运算符 （三目运算符）

<table> 
 <thead> 
  <tr> 
   <th align="center">分类</th> 
   <th align="center">运算符</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">一元运算符（单目运算符）</td> 
   <td align="center">正号（+）、负号（-）、++、–、!、~</td> 
  </tr> 
  <tr> 
   <td align="center">二元运算符（双目运算符）</td> 
   <td align="center">除了一元和三元运算符剩下的都是二元运算符</td> 
  </tr> 
  <tr> 
   <td align="center">三元运算符 （三目运算符）</td> 
   <td align="center">(条件表达式)?结果1:结果2</td> 
  </tr> 
 </tbody> 
</table>

###### 2.10.1 算术运算符 ######

<table> 
 <thead> 
  <tr> 
   <th align="center">算术运算符</th> 
   <th align="center">符号解释</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center"><code>+</code></td> 
   <td align="center">加法运算，字符串连接运算，正号</td> 
  </tr> 
  <tr> 
   <td align="center"><code>-</code></td> 
   <td align="center">减法运算，负号</td> 
  </tr> 
  <tr> 
   <td align="center"><code>*</code></td> 
   <td align="center">乘法运算</td> 
  </tr> 
  <tr> 
   <td align="center"><code>/</code></td> 
   <td align="center">除法运算，整数/整数结果还是整数</td> 
  </tr> 
  <tr> 
   <td align="center"><code>%</code></td> 
   <td align="center">求余运算，余数的符号只看被除数</td> 
  </tr> 
  <tr> 
   <td align="center"><code>++</code> 、 <code>--</code></td> 
   <td align="center">自增自减运算</td> 
  </tr> 
 </tbody> 
</table>

【1】加减乘除模

public class OperatorDemo01 {
        
    	public static void main(String[] args) {
        
    		int a = 3;
    		int b = 4;
    		
    		System.out.println(a + b);// 7
    		System.out.println(a - b);// -1
    		System.out.println(a * b);// 12
    		System.out.println(a / b);// 计算机结果是0，为什么不是0.75呢？
    		System.out.println(a % b);// 3
            
            System.out.println(5%2);//1
    		System.out.println(5%-2);//1
    		System.out.println(-5%2);//-1
    		System.out.println(-5%-2);//-1		
    		//商*除数 + 余数 = 被除数
    		//5%-2  ==>商是-2，余数时1    (-2)*(-2)+1 = 5
    		//-5%2  ==>商是-2，余数是-1   (-2)*2+(-1) = -4-1=-5
    	}
    }

![在这里插入图片描述][9a5a4e4d990f49db985bb1ed2abc906a.png_pic_center]

![在这里插入图片描述][f141b07f6f6d4a07bbf02fdcfe394a49.png_pic_center]

【2】“+”号的两种用法

*  第一种：对于`+`两边都是数值的话，`+`就是加法的意思
 *  第二种：对于`+`两边至少有一边是字符串得话，`+`就是拼接的意思

public class OperatorDemo02 {
    	public static void main(String[] args) {
    		// 字符串类型的变量基本使用
    		// 数据类型 变量名称 = 数据值;
    		String str1 = "Hello";
    		System.out.println(str1); // Hello
    		
    		System.out.println("Hello" + "World"); // HelloWorld
    		
    		String str2 = "Java";
    		// String + int --> String
    		System.out.println(str2 + 520); // Java520
    		// String + int + int
    		// String		+ int
    		// String
    		System.out.println(str2 + 5 + 20); // Java520
    	}
    }

![在这里插入图片描述][e991ebe9f2d44ad6bf09205de6247d1a.png_pic_center]

![在这里插入图片描述][a423977b30e2490295e06756398b2b81.png_pic_center]

【3】自加自减运算

**理解：**`++` **运算，变量自己的值加1**。反之，`--` 运算，变量自己的值减少1，用法与`++` 一致。

1.  单独使用

*  变量在单独运算的时候，变量`前++`和变量`后++`，变量的是一样的；
 *  变量`前++` ：例如 `++a` 。
 *  变量`后++` ：例如 `a++` 。

public class OperatorDemo3 {
        
    	public static void main(String[] args) {
        
    		// 定义一个int类型的变量a
    		int a = 3;
    		//++a;
    		a++;
            // 无论是变量前++还是变量后++，结果都是4
    		System.out.println(a);
    	}
    }

![在这里插入图片描述][94b811a4abb04ff7915b2fc6de8c7477.png_pic_center]

![在这里插入图片描述][8abab3fd71b04a5e998a205f492c0abb.png_pic_center]

1.  复合使用

*  和`其他变量放在一起使用`或者和`输出语句放在一起使用`，`前++`和`后++`就产生了不同。

*  变量`前++` ：变量先自身加1，然后再取值。
 *  变量`后++` ：变量先取值，然后再自身加1。

public class OperatorDemo03 {
        
    	public static void main(String[] args) {
        
    		// 其他变量放在一起使用
    		int x = 3;
    		//int y = ++x; // y的值是4，x的值是4，
    		int y = x++; // y的值是3，x的值是4
    		
    		System.out.println(x);
    		System.out.println(y);
    		System.out.println("==========");
            
    		// 和输出语句一起
    		int z = 5;
    		//System.out.println(++z);// 输出结果是6，z的值也是6
    		System.out.println(z++);// 输出结果是5，z的值是6
    		System.out.println(z);
            
            int a = 1;
            a = a++;//(1)先取a的值“1”放操作数栈(2)a再自增,a=2(3)再把操作数栈中的"1"赋值给a,a=1
    
            int i = 1;
            int j = i++ + ++i * i++;
            /*
            从左往右加载
            (1)先算i++
            ①取i的值“1”放操作数栈
            ②i再自增 i=2
            （2）再算++i
            ①i先自增 i=3
            ②再取i的值“3”放操作数栈
            （3）再算i++
            ①取i的值“3”放操作数栈
            ②i再自增 i=4
            （4）先算乘法
            用操作数栈中3 * 3 = 9，并把9压会操作数栈
            （5）再算求和
            用操作数栈中的 1 + 9 = 10
            （6）最后算赋值
            j = 10
            */
    	} 
    }

![在这里插入图片描述][b4aac3e3fd394fd8be00d6b1ba4f5ba6.png_pic_center]

![在这里插入图片描述][5ee0a51d458547808dfe9bc7eb0cc097.png_pic_center]

*  小结：
    
     *  **++在前，先自加，后使用；**
     *  **++在后，先使用，后自加。**

*  分析

public class TestIncrementOperator1{
        
    	public static void main(String[] args){
        
    		int i = 1;
    		i++;
    		++i;
    	}
    }

![在这里插入图片描述][e9404174af9a4591ab26c6f2fa05d735.png_pic_center]

public class TestIncrementOperator2{
        
    	public static void main(String[] args){
        
    		int i = 1;
    		i = i++;
    	}
    }

![在这里插入图片描述][b4a0abd34db24228988d8435c87164b5.png_pic_center]

public class TestIncrementOperator3{
        
    	public static void main(String[] args){
        
    		int i = 1;
    		i = ++i;
    	}
    }

![在这里插入图片描述][7b1baf443def4eed983905889e76b430.png_pic_center]

###### 2.10.2 关系运算符/比较运算符 ######

<table> 
 <thead> 
  <tr> 
   <th align="center">关系运算符</th> 
   <th align="center">符号解释</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center"><code>&lt;</code></td> 
   <td align="center">比较符号左边的数据是否小于右边的数据，如果小于结果是true。</td> 
  </tr> 
  <tr> 
   <td align="center"><code>&gt;</code></td> 
   <td align="center">比较符号左边的数据是否大于右边的数据，如果大于结果是true。</td> 
  </tr> 
  <tr> 
   <td align="center"><code>&lt;=</code></td> 
   <td align="center">比较符号左边的数据是否小于或者等于右边的数据，如果大于结果是false。</td> 
  </tr> 
  <tr> 
   <td align="center"><code>&gt;=</code></td> 
   <td align="center">比较符号左边的数据是否大于或者等于右边的数据，如果小于结果是false。</td> 
  </tr> 
  <tr> 
   <td align="center"><code>==</code></td> 
   <td align="center">比较符号两边数据是否相等，相等结果是true。</td> 
  </tr> 
  <tr> 
   <td align="center"><code>！=</code></td> 
   <td align="center">不等于符号 ，如果符号两边的数据不相等，结果是true。</td> 
  </tr> 
 </tbody> 
</table>

*  比较运算符，是两个数据之间进行比较的运算，运算结果一定是boolean值`true`或者`false` 。
 *  其中>,<,>=,<=不支持boolean，String类型，==和!=支持boolean和String。

public class OperatorDemo05 {
        
    	public static void main(String[] args) {
        
    		int a = 3;
    		int b = 4;
    
    		System.out.println(a < b); // true
    		System.out.println(a > b); // false
    		System.out.println(a <= b); // true
    		System.out.println(a >= b); // false
    		System.out.println(a == b); // false
    		System.out.println(a != b); // true
    	}
    }

![在这里插入图片描述][14088ea19923415bba4e80ccabe2afd0.png_pic_center]

![在这里插入图片描述][1598d835f8f84152aec8d7bf2ccd2a20.png_pic_center]

###### 2.10.3 逻辑运算符 ######

*  逻辑运算符，是用来连接两个布尔类型值的运算符（`!`除外），运算结果也是boolean值`true`或者`false`

<table> 
 <thead> 
  <tr> 
   <th align="center">逻辑运算符</th> 
   <th align="center">符号解释</th> 
   <th align="center">符号特点</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center"><code>&amp;</code></td> 
   <td align="center">与，且</td> 
   <td align="center">有<code>false</code>则<code>false</code></td> 
  </tr> 
  <tr> 
   <td align="center">`</td> 
   <td align="center">`</td> 
   <td align="center">或</td> 
  </tr> 
  <tr> 
   <td align="center"><code>^</code></td> 
   <td align="center">异或</td> 
   <td align="center">相同为<code>false</code>，不同为<code>true</code></td> 
  </tr> 
  <tr> 
   <td align="center"><code>!</code></td> 
   <td align="center">非</td> 
   <td align="center">非<code>false</code>则<code>true</code>，非<code>true</code>则<code>false</code></td> 
  </tr> 
  <tr> 
   <td align="center"><code>&amp;&amp;</code></td> 
   <td align="center">双与，短路与</td> 
   <td align="center">左边为false，则右边就不看</td> 
  </tr> 
  <tr> 
   <td align="center">`</td> 
   <td align="center"></td> 
   <td align="center">`</td> 
  </tr> 
 </tbody> 
</table>

&&和&区别，||和|区别：

*  \*\*`&&`和`&`\*\*区别：
    
     *  `&&`和`&`结果一样，`&&`有短路效果，左边为false，右边不执行；`&`左边无论是什么，右边都会执行。
 *  \*\*`||`和`|`\*\*区别：
    
     *  `||`和`|`结果一样，`||`有短路效果，左边为true，右边不执行；`|`左边无论是什么，右边都会执行。

public class OperatorDemo06 {
        
    	public static void main(String[] args) {
        
    		int a = 3;
    		int b = 4;
    		int c = 5;
    
    		// & 与，且；有false则false
    		System.out.println((a > b) & (a > c)); 
    		System.out.println((a > b) & (a < c)); 
    		System.out.println((a < b) & (a > c)); 
    		System.out.println((a < b) & (a < c)); 
    		System.out.println("===============");
    		// | 或；有true则true
    		System.out.println((a > b) | (a > c)); 
    		System.out.println((a > b) | (a < c)); 
    		System.out.println((a < b) | (a > c));
    		System.out.println((a < b) | (a < c));
    		System.out.println("===============");
    		// ^ 异或；相同为false，不同为true
    		System.out.println((a > b) ^ (a > c));
    		System.out.println((a > b) ^ (a < c)); 
    		System.out.println((a < b) ^ (a > c)); 
    		System.out.println((a < b) ^ (a < c)); 
    		System.out.println("===============");
    		// ! 非；非false则true，非true则false
    		System.out.println(!false);
    		System.out.println(!true);
            
            //&和&&的区别
            System.out.println((a > b) & (a++ > c)); 
            System.out.println("a = " + a);
            System.out.println((a > b) && (a++ > c)); 
            System.out.println("a = " + a);
            System.out.println((a == b) && (a++ > c)); 
            System.out.println("a = " + a);
            
            //|和||的区别
            System.out.println((a > b) | (a++ > c)); 
            System.out.println("a = " + a);
            System.out.println((a > b) || (a++ > c)); 
            System.out.println("a = " + a);
            System.out.println((a == b) || (a++ > c)); 
            System.out.println("a = " + a);
    	}
    }

![在这里插入图片描述][8b91bb6fb30145a5908fe73826a07ef9.png_pic_center]

![在这里插入图片描述][9b78eb7540a34487a918316b40fdd25e.png_pic_center]

/*
    3、逻辑运算符
    逻辑与：&
    	true & true 结果是true
    	true & false 结果是false
    	false & true 结果是false
    	false & false 结果是false
    	
    	只有两个边都是true，结果才为true。
    
    逻辑或：|
    	true | true 结果是true
    	true | false 结果是true
    	false | true 结果是true
    	false | false 结果是false
    	
    	只要有一边是true，结果就为true。
    	
    逻辑非：!
    	!true  变为false
    	!false 变为true
    	
    逻辑异或：^
    	true | true 结果是false
    	true | false 结果是true
    	false | true 结果是true
    	false | false 结果是false
    	
    	只有两边不一样，一个是true，一个是false，结果才为true。
    	
    短路与：&&
    	true && true 结果是true
    	true && false 结果是false
    	false && ? 结果是false
    	false && ? 结果是false
    	
    	只有两个边都是true，结果才为true。
    	但是它如果左边已经是false，右边不看。这样的好处就是可以提高效率。
    
    	
    短路或：||
    	true || ？ 结果是true
    	true || ？ 结果是true
    	false || true 结果是true
    	false || false 结果是false
    	
    	只要有一边是true，结果就为true。
    	但是它如果左边已经是true，右边就不看了。这样的好处就是可以提高效率。
    
    特殊：
    （1）逻辑运算符的操作数必须是boolean值
    （2）逻辑运算符的结果也是boolean值
    
    */
    public class LogicOperator{
        
    	public static void main(String[] args){
        
    		/*
    		表示条件，成绩必须在[0,100]之间
    		成绩是int类型变量score
    		*/
    		int score = 56;
    		
    		//System.out.println(0<=score<=100);
    		/*
    		LogicOperator.java:23: 错误: 二元运算符 '<=' 的操作数类型错误
                    System.out.println(0<=score<=100);
                                               ^
    		  第一个类型:  boolean    0<=score的结果 true
    		  第二个类型: int
    		  
    		  true <= 100？不对的
    		1 个错误*/
    		
    		System.out.println(0<=score  & score<=100);
    		
    	}
    }

![在这里插入图片描述][526f4c2816d54a03a452b90305623c03.png_pic_center]

![在这里插入图片描述][15d0cc438142406fbfd3852eb3575278.png_pic_center]

###### 2.10.4 条件运算符 ######

*  条件运算符格式：

条件表达式？结果1：结果2

*  条件运算符计算方式：
    
     *  条件判断的结果是true，条件运算符整体结果为结果1，赋值给变量。
     *  判断条件的结果是false，条件运算符整体结果为结果2，赋值给变量。

public static void main(String[] args) {
        
        int i = (1==2 ? 100 : 200);
        System.out.println(i);//200
        int j = (3<=4 ? 500 : 600);
        System.out.println(j);//500
    }

public class ConditionOperator{
        
    	public static void main(String[] args){
        
    		//判断两个变量a,b谁大，把大的变量赋值给max
    		int a = 2;
    		int b = 2;
    		int max = a >= b ? a : b;
    		//如果a>=b成立，就取a的值赋给max，否则取b的值赋给max
    		System.out.println(max);
    		
    		boolean marry = false;
    		System.out.println(marry ? "已婚" : "未婚"  );
    	}
    }

![在这里插入图片描述][c022720ef19447449211597e3f4f5c49.png_pic_center]

![在这里插入图片描述][d740d244b7904c56b3d65c2130972a28.png_pic_center]

###### 2.10.5 位运算符 ######

<table> 
 <thead> 
  <tr> 
   <th align="center">位运算符</th> 
   <th align="center">符号解释</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center"><code>&amp;</code></td> 
   <td align="center">按位与，当两位相同时为1时才返回1</td> 
  </tr> 
  <tr> 
   <td align="center">`</td> 
   <td align="center">`</td> 
  </tr> 
  <tr> 
   <td align="center"><code>~</code></td> 
   <td align="center">按位非，将操作数的每个位（包括符号位）全部取反</td> 
  </tr> 
  <tr> 
   <td align="center"><code>^</code></td> 
   <td align="center">按位异或。当两位相同时返回0，不同时返回1</td> 
  </tr> 
  <tr> 
   <td align="center"><code>&lt;&lt;</code></td> 
   <td align="center">左移运算符</td> 
  </tr> 
  <tr> 
   <td align="center"><code>&gt;&gt;</code></td> 
   <td align="center">右移运算符</td> 
  </tr> 
  <tr> 
   <td align="center"><code>&gt;&gt;&gt;</code></td> 
   <td align="center">无符号右移运算符</td> 
  </tr> 
 </tbody> 
</table>

*  **位运算符的运算过程都是基于补码运算**，但是看结果，我们得换成原码，再换成十进制看结果
 *  从二进制到十进制都是基于原码
 *  正数的原码反码补码都一样，负数原码反码补码不一样
 *  byte,short,char在计算时按照int类型处理

> 如何区分&,|,^是逻辑运算符还是位运算符？
> 
> 【如果操作数是boolean类型，就是逻辑运算符，如果操作数是整数，那么就位运算符。】

【1】左移：<<

运算规则：左移几位就相当于乘以2的几次方

\*\*注意：\*\*当左移的位数n超过该数据类型的总位数时，相当于左移（n-总位数）位

byte,short,char在计算时按照int类型处理

3<<4  类似于  3*2的4次= 3*16 = 48

![在这里插入图片描述][836de8e5a0114bba9ad85c095b57e854.png_pic_center]

-3<<4  类似于  -3*2的4次= -3*16 = -48

![在这里插入图片描述][681d77c991714e8eba6f0fe8d7b54fc3.png_pic_center]

【2】右移：>>

快速运算：类似于除以2的n次，如果不能整除，**向下取整**

69>>4  类似于  69/2的4次 = 69/16 =4

![在这里插入图片描述][40c6640da1274cf68d2a77038c1a1366.png_pic_center]

-69>>4  类似于  -69/2的4次 = -69/16 = -5

![在这里插入图片描述][77a1ab04c48b4d47b1a7c96d4ca9be5f.png_pic_center]

【3】无符号右移：>>>

运算规则：往右移动后，左边空出来的位直接补0，不看符号位

正数：和右移一样

负数：右边移出去几位，左边补几个0，结果变为正数

69>>>4  类似于  69/2的4次 = 69/16 =4

![在这里插入图片描述][11df87620e054bf481b69881c9c27b5c.png_pic_center]

-69>>>4   结果：268435451

![在这里插入图片描述][fc912cbc682643359285e780c5762d84.png_pic_center]

【4】按位与：&

运算规则：对应位都是1才为1

1 & 1 结果为1

1 & 0 结果为0

0 & 1 结果为0

0 & 0 结果为0

9&7 = 1

![在这里插入图片描述][f41b706e6eb0417ca5b2c95370e9b4b0.png_pic_center]

-9&7 = 7

![在这里插入图片描述][e6279d1261464f2ea337b0c39f303961.png_pic_center]

【5】按位或：|

运算规则：对应位只要有1即为1

1 | 1 结果为1

1 | 0 结果为1

0 | 1 结果为1

0 & 0 结果为0

9|7  结果： 15

![在这里插入图片描述][91551f45a57848c59885c36b916f0d11.png_pic_center]

-9|7 结果： -9

![在这里插入图片描述][412529de10624beeae38bd580caadc52.png_pic_center]

【6】按位异或：^

运算规则：对应位一个为1一个为0，才为1

1 ^ 1 结果为0

1 ^ 0 结果为1

0 ^ 1 结果为1

0 ^ 0 结果为0

9^7  结果为14

![在这里插入图片描述][eb60ffa8eff7423c8ef15b0b7ef91461.png_pic_center]

-9^7 结果为-16

![在这里插入图片描述][c1ece5f3bfc14ed4a329f7aa16c7b501.png_pic_center]

【7】按位取反：~

运算规则：~0就是1

~1就是0

~9  结果：-10

![在这里插入图片描述][5d78a8417ded420b908466c75acb4cb6.png_pic_center]

~-9  结果：8

![在这里插入图片描述][ad152cbb08b446a6884cf0cb52be49b7.png_pic_center]

###### 2.10.6 赋值运算符 ######

<table> 
 <thead> 
  <tr> 
   <th align="center">运算符</th> 
   <th align="center">符号解释</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">=</td> 
   <td align="center">将右边的常量值/变量值/表达式的值，赋值给左边的变量</td> 
  </tr> 
  <tr> 
   <td align="center">+=</td> 
   <td align="center">将左边变量的值和右边的常量值/变量值/表达式的值进行相加，最后将结果赋值给左边的变量</td> 
  </tr> 
  <tr> 
   <td align="center">-=</td> 
   <td align="center">将左边变量的值和右边的常量值/变量值/表达式的值进行相减，最后将结果赋值给左边的变量</td> 
  </tr> 
  <tr> 
   <td align="center">*=</td> 
   <td align="center">将左边变量的值和右边的常量值/变量值/表达式的值进行相乘，最后将结果赋值给左边的变量</td> 
  </tr> 
  <tr> 
   <td align="center">/=</td> 
   <td align="center">将左边变量的值和右边的常量值/变量值/表达式的值进行相除，最后将结果赋值给左边的变量</td> 
  </tr> 
  <tr> 
   <td align="center">%=</td> 
   <td align="center">将左边变量的值和右边的常量值/变量值/表达式的值进行相模，最后将结果赋值给左边的变量</td> 
  </tr> 
  <tr> 
   <td align="center">&lt;&lt;=</td> 
   <td align="center">将左边变量的值左移右边常量/变量值/表达式的值的相应位，最后将结果赋值给左边的变量</td> 
  </tr> 
  <tr> 
   <td align="center">&gt;&gt;=</td> 
   <td align="center">将左边变量的值右移右边常量/变量值/表达式的值的相应位，最后将结果赋值给左边的变量</td> 
  </tr> 
  <tr> 
   <td align="center">&gt;&gt;&gt;=</td> 
   <td align="center">将左边变量的值无符号右移右边常量/变量值/表达式的值的相应位，最后将结果赋值给左边的变量</td> 
  </tr> 
  <tr> 
   <td align="center">&amp;=</td> 
   <td align="center">将左边变量的值和右边的常量值/变量值/表达式的值进行按位与，最后将结果赋值给左边的变量</td> 
  </tr> 
  <tr> 
   <td align="center">|=</td> 
   <td align="center">将左边变量的值和右边的常量值/变量值/表达式的值进行按位或，最后将结果赋值给左边的变量</td> 
  </tr> 
  <tr> 
   <td align="center">^=</td> 
   <td align="center">将左边变量的值和右边的常量值/变量值/表达式的值进行按位异或，最后将结果赋值给左边的变量</td> 
  </tr> 
 </tbody> 
</table>

public class OperatorDemo04 {
        
    	public static void main(String[] args) {
        
    		int a = 3;
    		int b = 4;
            int c = a + b;        
            
    		b += a;// 相当于 b = b + a ; 
    		System.out.println(a); // 3
    		System.out.println(b); // 7	
            System.out.println(c); //7
    		
    		short s = 3;
    		// s = s + 4; 代码编译报错，因为将int类型的结果赋值给short类型的变量s时，可能损失精度
    		s += 4; // 代码没有报错
            //因为在得到int类型的结果后，JVM自动完成一步强制类型转换，将int类型强转成short
    		System.out.println(s);
            
            int j = 1;
    		j += ++j * j++;//相当于  j = j + (++j * j++);
    		System.out.println(j);//5
            
            int m = 1;
            m <<= 2;
            System.out.println(m);
    	}
    }

![在这里插入图片描述][2ca9acaf269c479d9904aaf6fe0125b7.png_pic_center]

![在这里插入图片描述][44b93976c94c4116b47d71e37b0df582.png_pic_center]

*  扩展赋值运算符在**将最后的结果赋值给左边的变量前，多做了一步强制类型转换**。
 *  注意：所有的赋值运算符的=左边一定是一个变量

###### 2.10.7 运算符优先级 ######

![在这里插入图片描述][fbfe5a7df71e4ff1af38dbf2fbc37fad.png_pic_center]

提示说明：

（1）表达式不要太复杂

（2）先算的使用()

**口诀：**

单目运算排第一；

乘除余二加减三；

移位四，关系五；

等和不等排第六；

位与、异或和位或；

短路与和短路或；

依次从七到十一；

条件排在第十二；

赋值一定是最后；

[ea1d2271f2eb4f6f96a02a7137e903f6.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/adbf2d2a5a0c49ec9e02df9d44e41d5b.png
[f0abea1c43a44522ae36449cb550fd03.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/ffff6361790d449eb7e140fb263bbd18.png
[9a5a4e4d990f49db985bb1ed2abc906a.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/6c06697974e04a6dbc51c9296f1e3817.png
[f141b07f6f6d4a07bbf02fdcfe394a49.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/3afda53008bd499190346d56bb520160.png
[e991ebe9f2d44ad6bf09205de6247d1a.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/e49bf43b732f49bf887e72992eaf4a1e.png
[a423977b30e2490295e06756398b2b81.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/4837b7d46ed740ae9cd572ee1190b578.png
[94b811a4abb04ff7915b2fc6de8c7477.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/e484c3823fcb415bb363ade9f4f0efb6.png
[8abab3fd71b04a5e998a205f492c0abb.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/5ab752bbf663412f9c69525a2054abd6.png
[b4aac3e3fd394fd8be00d6b1ba4f5ba6.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/43787355ebdb48bba6bd424791c83d86.png
[5ee0a51d458547808dfe9bc7eb0cc097.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/37ba58c06a1a43469b2702ebc63d7941.png
[e9404174af9a4591ab26c6f2fa05d735.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/3603d8bf3cd74ca19a9bbc0673857c53.png
[b4a0abd34db24228988d8435c87164b5.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/0e8284b949a94f9ea7f4596ada8f4893.png
[7b1baf443def4eed983905889e76b430.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/7097fb3aa8bd48c08926defef31a2432.png
[14088ea19923415bba4e80ccabe2afd0.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/ddcb268eaf0a4709885e10a3eca84bc6.png
[1598d835f8f84152aec8d7bf2ccd2a20.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/f38770aecaf549c5a57a363285d2cc04.png
[8b91bb6fb30145a5908fe73826a07ef9.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/cb85c5e82b2e44199415c9a1274f44e5.png
[9b78eb7540a34487a918316b40fdd25e.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/5ebaba91e1dc4497ad7502c3f019cf64.png
[526f4c2816d54a03a452b90305623c03.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/3716e5cd4f78465d90eb2385862a710e.png
[15d0cc438142406fbfd3852eb3575278.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/3a8af8cd42f147bab2b61050ac110b3b.png
[c022720ef19447449211597e3f4f5c49.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/10bead9133eb4bc4a818644f3a562561.png
[d740d244b7904c56b3d65c2130972a28.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/7289da81e02f4727bbab277dbc37ce2d.png
[836de8e5a0114bba9ad85c095b57e854.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/342f61a3e3634dfda2993d5fa06704c6.png
[681d77c991714e8eba6f0fe8d7b54fc3.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/fd53bf7b0ac64c73a5ddc1c573839598.png
[40c6640da1274cf68d2a77038c1a1366.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/679e9c179f1b4207bad78b728ea152c4.png
[77a1ab04c48b4d47b1a7c96d4ca9be5f.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/08b7da49779c418aba3213716e01a8e2.png
[11df87620e054bf481b69881c9c27b5c.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/f2c7e24027b44d76a55c72e594b57805.png
[fc912cbc682643359285e780c5762d84.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/5cf2f771feff492bafe238f93de6e0c4.png
[f41b706e6eb0417ca5b2c95370e9b4b0.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/9d16b6a5909a43758d8d1131fd956a49.png
[e6279d1261464f2ea337b0c39f303961.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/cde841f84832423e897efe47bdce7919.png
[91551f45a57848c59885c36b916f0d11.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/c9c88527b58c47acaa15cb080fb48a97.png
[412529de10624beeae38bd580caadc52.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/7936c60f05e84d7fb63cefb19caa0754.png
[eb60ffa8eff7423c8ef15b0b7ef91461.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/6994e84596034ae18930223bed75cd82.png
[c1ece5f3bfc14ed4a329f7aa16c7b501.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/174be59b9e7a42cd955d7d596b4dc042.png
[5d78a8417ded420b908466c75acb4cb6.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/a2d2ddf749f6450eb6f96940681afae3.png
[ad152cbb08b446a6884cf0cb52be49b7.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/57b71fa5f45c48fe99fd5c434fe80fe6.png
[2ca9acaf269c479d9904aaf6fe0125b7.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/e67de9b6ba6a492fbc9ff3c075252b29.png
[44b93976c94c4116b47d71e37b0df582.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/44232597357942c38296dab96c2713ac.png
[fbfe5a7df71e4ff1af38dbf2fbc37fad.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/6f1db3ed5edf4cf284209a14093181a8.png