Javase | 运算符

1.算术运算符

• 在Java中，算术运算符用于执行各种数学运算，包括 加法 、减法、乘法、除法、 取模/取余 等。

• 运算符	含义	举例	结果
  +	加法运算符	a+b	a和b的和
  -	减法运算符	a-b	a和b的差
  *	乘法运算符	a*b	a和b的乘积
  /	除法运算符	a/b	a除以b的商
  %	求余运算符	a%b	a除以b的余数
  ++	自增运算符（本身值+1）	++a	先 ++，再操作
  ++	自增运算符（本身值+1）	a++	先操作，再 ++
  - -	自减运算符（本身值-1）	- -a	先 --，再操作
  - -	自减运算符（本身值-1）	a- -	先操作，再 - -

• 以下是在Java中使用算术运算符的示例：

    public class ArithmeticOperator {
     
      //算术运算符
     public static void main(String[] args) {
     
     
      int a = 10;
      int b = 3;
      double c = 10.0;
      double d = 3.0;

      // 加法
      int sum = a+b;
      System.out.println("Sum: "+sum);

      // 减法
      int subtract = a-b;
      System.out.println("subtract: "+subtract);

      // 乘法
      int mul = a*b;
      System.out.println("mul: "+mul); //输出30
      double mul2 = c*d;
      System.out.println("mul2: "+mul2);  //输出30.0

      // 除法
      int divi = a/b;   //两数相除，得其商。此时 10/3=3....1 ，商为3
      System.out.println("divi: "+divi);  //输出3
      double divi2 = c/d;   //两数相除，得其商。此时 10/3=3....1 ，商为3
      System.out.println("divi2: "+divi2);  //此处输出3.3333333333333335

      // 取模（取余）
      int remainder = a % b;   // 两数相除，得其数。此时 10/3=3....1 ，余数为1
      System.out.println("Remainder: "+remainder); //此处输出1


       a = 10;
      // a++  先操作，再++，先执行输出语句，再自增。
    System.out.println(a++); //输出10

      a = 10;
    // ++a  先++作，再操作，先自增，再执行输出语句。
    System.out.println(++a); //输出11

      a = 10;
      // a--  先操作，再--，先执行输出语句，再自减。
    System.out.println(a--); //输出10。

      a = 10;
    // --a  先--，再操作，先自减，再执行输出语句。
    System.out.println(--a); //输出9
     }
    }

​

2.关系运算符

• 关系运算符的结果值皆为布尔值。

  运算符	含义	优先级	举例	结果
  <	小于	优先级相同（高）	5<10	true
  <=	小于等于	优先级相同（高）	5<=10	true
  >	大于	优先级相同（高）	5>10	false
  >=	大于等于	优先级相同（高）	5>=10	false
  ==	等于	优先级相同（低）	5==10	false
  !=	不等于	优先级相同（低）	5!=10	true

• < 、<=、>、>=四个优先级是同一级别( 高 )，==、!= 优先级是同一级别( 低 )

• 以下是在Java中使用关系运算符的示例：

    int a = 5;
    int b = 10;
    boolean result;

    //小于
    result = (a<b);
    System.out.println(result);   // 输出 true

    //小于等于
    result = (a<=b);
    System.out.println(result);   // 输出 true

    //大于
    result1 = (a>b);
    System.out.println(result1);   // 输出 false

    //大于等于
    result = (a>=b);
    System.out.println(result);   // 输出 false

    //等于
    result = (a==b);
    System.out.println(result);   // 输出 false

    //不等于
    result = (a!=b);
    System.out.println(result);   // 输出 true

以上例子中，关系运算符返回的结果为布尔值，即 true 或 false。根据结果的不同，程序可以做出不同的逻辑判断或执行不同的操作。

​

3.赋值运算符

• Java中的赋值运算符用于给变量或常量赋值。

• 运算符	含义	举例	结果
  =	等于	int a = b	a=b,赋值
  +=	加等于	a +=b	a = a+b
  -=	减等于	a -= b	a=a-b
  *=	乘等于	a *= b	a=a*b
  /=	除等于	a /= b	a=a/b
  %=	取余等于	a %= b	a=a%b

• 以下是在Java中使用赋值运算符的示例：

    //等于
    int a = 10;
    System.out.println(a);       //10

    //加等于
    a = 10;
    System.out.println(a += 5);	  //15

    //减等于
    a = 10;
    System.out.println(a -= 5);   //5

    //乘等于
    a = 10;
    System.out.println(a *= 5);   //50

    //除等于
    a = 10;
    System.out.println(a /= 5);	  //2

    //取余等于
    a = 10;
    System.out.println(a %= 5); 	//0

这些赋值运算符可以用于基本数据类型（如整数、浮点数、字符等）和引用类型（如对象、数组等）

​

4.逻辑运算符

• Java中的逻辑运算符用于对布尔表达式进行逻辑操作，它们可以用于判断表达式的真伪，从而决定程序的下一步的执行。

运算符	含义	举例	说明	tips
&&	逻辑与（and）	a&&b	如果a和b都为真，则结果真，否则为假	两真才真，有假则假
||	逻辑或（or）	a||b	只要a和b有一个是真，则结果为真，二者为假时，结果才为假	有真则真，两假才假
!	逻辑非（not）	!a	如果a为假，则 !a为真；如果a为真，则 !a为假

• &&和||是双目 (元)运算符，它要求有两个运算对象（操作数）
• ! 是单目运算符，只要求有一个运算对象（操作数）
• 以下是在Java中使用逻辑运算符的示例：

    boolean a = true;
    boolean b = false;

    //逻辑与
    System.out.println(a&&b);  //false

    //逻辑或
    System.out.println(a||b);  //true

    //逻辑非
    System.out.println(!a);   //false

在这些例子中，我们使用了逻辑运算符来对布尔值进行操作，从而得到新的布尔结果。与运算符（&&）在两个表达式都为真时返回真，或运算符（||）在两个表达式中只要有一个为真时返回真，非运算符（！）将一个表达式的值取反。

​

5.字符串连接运算符

在Java中，字符串连接运算符是 “+”，它可以用于将两个字符串连接起来。例如：

    String str1 = "Hello";
    String str2 = "world";

    //用字符串连接符连接字符串
    String str3 = str1 + " " + str2;   // str3为"Hello world"

在上面的例子中，"+"运算符将三个字符串连接起来，中间用空格分隔。

注意，在Java中，使用"+"运算符连接字符串时，如果其中有一个操作数是字符串，那么其他操作数也会自动转换为字符串类型。

​

6.三元运算符

Java中的三元运算符（也称为条件运算符）具有以下形式：

条件表达式?表达式1:表达式2

其中，如果条件表达式为真 (true)，则执行表达式1，否则执行表达式2。

三元运算符的优先级较低，低于其他大多数运算符。

以下是使用三元运算符的示例：

int a = 80;
int b = 100;

int max = (a>b)?a:b;    // a>b为false，所以执行表达式2，有max=100

​

7.位运算符

7.1 原码

• 原码是最直观的表示方式，即将一个整数的绝对值转换成二进制，并在最高位加上符号位（0代表正数，1代表负数）。
• 例如，十进制数
  • +5的原码表示为 00000000 00000000 00000000 00000101 (最高位为符号位)
  • -5的原码表示为 10000000 00000000 00000000 00000101
• 正数的原码、补码、反码相同。

7.2 反码

• 正数的原码 = 反码。
• 负数的反码是将其原码除符号位外的各个位取反。（除了符号位，其他各位都取反）。
• 例如，十进制数
  • +5的反码为 00000000 00000000 00000000 00000101 (最高位为符号位)
  • -5的反码为 11111111 11111111 11111111 11111010
• 注意点：
  • 按位取反( ~ )是对所有位都进行取反，这与负数的反码的除符号位外的各个位取反不同。

7.3 补码

• 正数的原码 = 补码。
• 负数的**补码 **= 反码末位+1 ( 最低位+1，不操作符号位的，只对末尾+1)
• 例如，十进制数
  • +5的补码为 00000000 00000000 00000000 00000101 (最高位为符号位)
  • -5的补码为 11111111 11111111 11111111 11111011
• Java中位运算符是对补码进行操作的。

7.4 原码、反码、补码的快速转化

• 正数原码 = 反码 = 补码 / 正数补码 = 反码 = 原码
• 负数原码转化为补码：符号位不变，数值位按位取反，末尾加1。
• 负数补码转化为原码：符号位不变，数值位按位取反，末尾加1。
• 负数反码转化为补码：末尾加1。

7.5 位运算符：(位运算符操作的是补码)

• Java中的位运算符用于 处理二进制数。
• Java中 位运算符操作的是补码。
• Java中 二进制的符号位 (放在最高位) 是使用0表示正数，使用1表示负数。
• 易错点：
  对补码进行按位取反后，要先转化为原码，再转化为十进制数。

下面举例中 ：（最高位为符号位：0）
int a= 3，二进制原码/反码/补码为：00000000 00000000 00000000 00000011 （最高位为符号位：0）

int b = 6，二进制原码/反码/补码为：00000000 00000000 00000000 00000110 （最高位为符号位：0）

运算符	含义	说明 (操作的都是 补码)	举例	结果
&	按位与	两个位都为1时，结果为1，否则为0 (两1才1，否则为0)	a & b	2
|	按位或	两个位都为0时，结果为0，否则为1 (有1则1，两0才0)	a | b	7
^	按位异或	两个位相同时，结果为0，否则为1 （相同为0，否则为1）	a ^ b	5
~	按位取反	对二进制数的==每个位 (包括符号位) 取反，即0变为1，1变为0 （每个位取反，0变1,1变0）== 对补码进行按位取反后，要先转化为原码，再转化为十进制数	~a	-4
<<	左移位 (算术左移)	将一个数的二进制补码向左移动指定位数，右空位/低位补固定0 / 高位移除n个数，低位空位补0 / （左移指定位数，低位空位补0）	a << 2	12
>>	右移位 (算术右移)	将一个数的二进制补码向右移动指定位数，用符号位代表的0或1补空出的高位 / 低位移除n个数，高位空位补0或1 / （右移指定位数，高位空位补0或1）	a >> 2	0
>>>	无符号右移位（逻辑右移）	将一个数的二进制补码向右移动指定位数，左空位/高位补固定0 / 高位移除n个数，低位空位补0	a >>> 2	0

7.6 按位取反 和 反码的区别

运算符	含义	说明	区别
~	按位取反	对二进制数的 每个位 (包括符号位) 取反，即0变为1，1变为0 （取反，0变1,1变0） 对补码进行按位取反后，要先转化为原码，再转化为十进制数	对所有位取反
反码	反码	负数的反码是将其原码除符号位外的各个位取反。（除了符号位，其他各位都取反）	除了符号位不取反，其他个位 都取反

以下是在Java中使用位运算符的例子：

    //  原、反、补码: 00000000 00000000 00000000 00000011
    int a = 3;  
    //  原、反、补码: 00000000 00000000 00000000 00000110
    int b = 6;  
    //ps: 输出语句后的二进制皆为原码

    //按位与 运算符 (两1才1，有0则0)
    System.out.println(a&b);    //0000 0010 : 2

    //按位或 运算符 (有1则1，两0才0)
    System.out.println(a|b);    //0000 0111 : 7

    //按位异或 运算符 (相同为0，否则为1)
    System.out.println(a^b);    //0000 0101 : 5


    
     按位取反 运算符 :
       a = 3  原/反/补码: 00000000 00000000 00000000 00000011
       ~a :   补码: 	   11111111 11111111 11111111 11111100
              原码:      10000000 00000000 00000000 00000100 : -4
    System.out.println(~a);  //10000000 00000000 00000000 00000100 : -4


    
     左移位 运算符 :
     原、反、补码: 00000000 00000000 00000000 00000011
     a<<2: 左移位运算: (高位移除2个数字，低位空位补0) :        ---左移位运算 空位固定补0
                 00									     ---高位移除 (2个数)
                   000000 00000000 00000000 00000011
                                                    00   ---低位空位补0
           00000000 00000000 00000000 00001100 			 ---值为: 12 (正数原反补码相等)
	System.out.println(a<<2);  // 00000000 00000000 00000000 00001100 : 12


     
     右移位 运算符 :
     原、反、补码: 00000000 00000000 00000000 00000011
     a>>2: 右移位运算:  (低位移除2个数字，高位空位补0) : 此处为正数符号位为0，所以补0；负数则补1。
                                                  11	 ---低位移除
                 00000000 00000000 00000000 00000011
               00  										 ---高位空位补0	
           00000000 00000000 00000000 00000000    		 ---值为: 0    
      
	System.out.println(a>>2);  // 00000000 00000000 00000000 00000000 :  0


       
          无符号右移位 运算符 :
          原、反、补码: 00000000 00000000 00000000 00000011
          a>>>2: 无符号右移位运算:  (低位移除2个数字，高位空位补0) : ---无符号右移位 空位固定补0
                                                      11	  ---低位移除
                     00000000 00000000 00000000 00000011	
                   00										  ---高位空位补0
              00000000 00000000 00000000 00000000 			  ---值为: 0
	System.out.println(a>>>2); // 00000000 00000000 00000000 00000000 : 0

以下是在Java中使用位运算符的例子2：

    
     左移位 运算符 :
     原、反、补码: 00000000 00000000 00000000 00001111          ---: 15
      15<<3: 左移位运算: (高位移除3个数字，低位空位补0) :        ---左移位运算 空位固定补0
                 000									   ---高位移除 (3个数)
                    00000 00000000 00000000 00001111
                                                    000	   ---低位空位补0
         00000000 00000000 00000000 01111000			---值为: 120 (正数原反补码相等)		                							 
	System.out.println(15<<3); // 00000000 00000000 00000000 01111000 : 120



          左移位 运算符 :
              原码: 10000000 00000000 00000000 01111			  ---: -15
              反码: 11111111 11111111 11111111 10000
              补码: 11111111 11111111 11111111 10001
          -15<<3: 左移位运算: (高位移除3个数字，低位空位补0) :        ---左移位运算 空位固定补0   
                   111											---高位移除 (3个数)
                      11111 11111111 11111111 10001
                                                   000			---低位空位补0
         补码: 11111 11111111 11111111 10001000
         原码: 10000 00000000 00000000 01111000   	  		   ---值为: -120		   
	System.out.println(-15<<3); // 10000 00000000 00000000 01111000 : -120

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

     右移位 运算符 :
     原、反、补码:  00000000 00000000 00000000 00001111 
      15>>3: 右移位运算: (低位移除3个数字，高位空位补0) :  ---右移位运算，为正数且符号为0.所以补0
                                                  111       ---低位移除 (3个数)
                  00000000 00000000 00000000 00001
               000											---高位空位补0
          00000000 00000000 00000000 00000001				 ---值为: 1			   
	System.out.println(15>>3);  //  00000000 00000000 00000000 00000001 : 1


  
    右移位 运算符 :
         原码: 10000000 00000000 00000000 00001111
         反码: 11111111 11111111 11111111 11110000
         补码: 11111111 11111111 11111111 11110001
      -15>>3: 右移位运算: (低位移除3个数字，高位空位补0) : ---右移位运算，为负数且符号为1.所以补1
                                              001			 ---低位移除 (3个数)
              11111111 11111111 11111111 11110		
           111											     ---高位空位补1
      补码:11111111 11111111 11111111 11111110
      原码:10000000 00000000 00000000 00000010                ---值为: -2	
	System.out.println(-15>>3); 

----------------------------------------------------------------------------
    
  
    无符号右移位 运算符 :
     原、反、补码:  00000000 00000000 00000000 00001111 
      15>>3: 无符号右移位运算: (低位移除3个数字，高位空位补0) :  ---无符号右移位运算，空位固定补0
                                                  111        ---低位移除 (3个数)
                  00000000 00000000 00000000 00001
               000											 ---高位空位补0
          00000000 00000000 00000000 00000001				 ---值为: 1	  			  					 	  	 
	System.out.println(15>>>3);


    原码: 10000000 00000000 00000000 00001111 
    反码: 11111111 11111111 11111111 11110000
    补码: 11111111 11111111 11111111 11110001
   -15>>>3: 五符号右移位运算: (低位移除3个数字，高位空位补0) : 右移位运算，为正数且符号为0.所以补0
                                  		 001         --- 低位移除 (3个数)
		 11111111 11111111 11111111 11110
      000											 ---高位空位补0
  补码:00011111 11111111 11111111 11111110 			---这是个正数
  原码:00011111 11111111 11111111 11111110             ---值为: 536870910
	System.out.println(-15>>>3); // 00011111 11111111 11111111 11111110 :536870910

8.instanceof运算符

• instanceof运算符的语法形式：

  对象 instanceof 类名

• instanceof运算符 用于检查一个对象是否属于某个类或 或 是否属于这个类的子类。

• instanceof运算符 还能用于检查一个对象是否实现了某个特定的接口。

• 例如：( 检查类的例子)

     public class Example {
         
            
     //  instanceof运算符 用于检查一个对象是否属于某个类或 或 是否属于这个类的子类。
  
         public static void main(String[] args) {
         
         
             Animal animal = new Dog();
             //判断animal对象是否属于Dog类 或 是否属于Dog类的子类
             if(animal instanceof Dog) {
         
          //true
                 System.out.println("验证了animal对象属于Dog");
             }
  
             //判断animal对象是否属于Animal类 或 是否属于Animal类的子类
             if(animal instanceof Animal) {
         
          //true
                 System.out.println("验证了animal对象属于Animal类的子类");
             }
         }
     }
       	class Animal {
         
           //父类 	} 	 	class Dog extends Animal { //子类继承了父类 	} 	```
  

9.运算符的优先级

在Java中，=运算符的优先级决定了表达式中执行的顺序。

Java中的运算符按照优先级从高到低依次如下：

圆括号 () → 一元运算符 → 算术运算符 → 移位运算符 → 关系运算符 → 逻辑与、逻辑或运算符→ 三目运算符 → 赋值运算符

• 圆括号 ()，用于强制改变优先级。
• 一元运算符： 包括递增（++）和递减（–）运算符，正负号运算符（+，-），逻辑非（!）和类型转换运算符（(type)）。
• 算术运算符 ： 包括乘法（*），除法（/），和取模（%），（+）和减法（-）。
• 移位运算符 ： 包括左移（<<），右移（>>）和无符号右移（>>>）。
• 关系运算符 ： 包括小于（<），大于（>），小于等于（<=），大于等于（>=），instanceof（用于判断一个对象是否是某个类的实例），以及等于（==）和不等于（!=）。
• 逻辑与、逻辑或 运算符（&&）和逻辑或运算符（||）。
• 三目运算符（? :）。
• 赋值运算符 ： 包括简单赋值（=），加等（+=），减等（-=），乘等（*=），除等（/=），取模等（%=），左移等（<<=），右移等（>>=），无符号右移等（>>>=）以及按位与等（&=），按位或等（|=），按位异或等（^=），按位取反（~）和逻辑与等（&&=）和逻辑或等（||=）。
• 在表达式中，如果出现了多个运算符，那么根据运算符的优先级，来决定执行的顺序。