Javase | 运算符

目录:

    • 1.算术运算符
    • 2.关系运算符
    • 3.赋值运算符
    • 4.逻辑运算符
    • 5.字符串连接运算符
    • 6.三元运算符
    • 7.位运算符
      • 7.1 原码
      • 7.2 反码
      • 7.3 补码
      • 7.4 原码、反码、补码的快速转化
      • 7.5 位运算符:(位运算符操作的是补码)
      • 7.6 按位取反 和 反码的区别
    • 8.instanceof运算符
    • 9.运算符的优先级

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

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

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 如果ab都为,则结果,否则为 两真才真,有假则假
|| 逻辑或(or) a||b 只要ab有一个是,则结果为,二者为时,结果才为 有真则真,两假才假
! 逻辑非(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变为11变为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变为11变为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;负数则补111	 ---低位移除
                 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(用于判断一个对象是否是某个类的实例),以及等于(==)和不等于(!=)。
  • 逻辑与、逻辑或 运算符(&&)和逻辑或运算符(||)。
  • 三目运算符(? :)。
  • 赋值运算符 : 包括简单赋值(=),加等(+=),减等(-=),乘等(*=),除等(/=),取模等(%=),左移等(<<=),右移等(>>=),无符号右移等(>>>=)以及按位与等(&=),按位或等(|=),按位异或等(^=),按位取反(~)和逻辑与等(&&=)和逻辑或等(||=)。
  • 在表达式中,如果出现了多个运算符,那么根据运算符优先级,来决定执行的顺序。

你可能感兴趣的:(Java知识点-整合,java,开发语言)