Java运算符

Java运算符

一、算数运算符

符号	作用
+	加
-	减
*	乘
/	除
%	模
++	自加1
--	自减1

        int a = 10;
        int b = 3;
        int result = a + b;
        System.out.println(result);//13
        System.out.println(a + b);//13
        System.out.println(10 + 3);//13
        System.out.println(10 - 3);//7
        System.out.println(10 * 3);//30
        System.out.println(10 / 3);//3
        System.out.println(10 % 3);//1
​
        //++：
        //++a：先自增1，再使用
        int a = 10;
        System.out.println(++a);//11
        System.out.println(a);//11
        //b++：先使用，再自增1
        int b = 10;
        System.out.println(b++);//10
        System.out.println(b);//11
        
        //--：
        //--c：先自减1，再使用
        int c = 10;
        System.out.println(--c);//9
        System.out.println(c);//9
        //d--：先使用，再自减1
        int d = 10;
        System.out.println(d--);//10
        System.out.println(d);//9
​
        
        知识点：算数运算符的深入
        符号：+、-、*、/、%、++、--
        
        //特殊点1：byte类型做运算会先向上转型成int类型
        //注意：
        //  1.自动转型使用最高位补位
        //  2.强制转型从最高位开始舍弃
        byte b1 = 10;
        byte b2 = 20;
        
        //b1 - byte：0000,1010
        //      int：0000,0000,0000,0000,0000,0000,0000,1010
        //b2 - byte：0001,0100
        //      int：0000,0000,0000,0000,0000,0000,0001,0100
        //      int：0000,0000,0000,0000,0000,0000,0001,1110
        //   (byte)：0001,1110
        
        byte result = (byte)(b1 + b2);
        System.out.println(result);
        
        //特殊点2：short类型做运算会先向上转型成int类型
        short s1 = 10;
        short s2 = 20;
        
        //s1 - short：0000,0000,0000,1010
        //       int：0000,0000,0000,0000,0000,0000,0000,1010
        //s2 - short：0000,0000,0001,0100
        //       int：0000,0000,0000,0000,0000,0000,0001,0100
        //       int：0000,0000,0000,0000,0000,0000,0001,1110
        //   (short)：0000,0000,0001,1110
        
        short result = (short)(s1 + s2);
        System.out.println(result);
        
        //特殊点3：byte和short类型做运算会先向上转型成int，其余数值型按照取值范围大的类型返回数据
        byte b = 10;
        short s = 10;
        int i = 10;
        long l = 10;
        float f = 10;
        double d = 10;
        
        System.out.println(b + b);//结果的数据类型是：int
        System.out.println(b + s);//结果的数据类型是：int
        System.out.println(b + i);//结果的数据类型是：int
        System.out.println(i + l);//结果的数据类型是：long
        System.out.println(i + f);//结果的数据类型是：float
        System.out.println(l + f);//结果的数据类型是：float
        System.out.println(l + d);//结果的数据类型是：double
        System.out.println(f + d);//结果的数据类型是：double
        
        //特殊点4：++a; 和 b++;没有区别，因为分号是执行语句的结束，不管先加还是后加都会加
        int a = 10;
        ++a;
        System.out.println(a);//11
        
        int b = 10;
        b++;
        System.out.println(b);//11
        
        //特殊点5：
        int num = 10;
        //底层实现：num = (int)(num+1);
        ++num;
        System.out.println(num);
        
        //特殊点6：char类型可以做运算
        char c = 'a';//'a'的码值是97
        int i = c+1;
        System.out.println(i);//98
        
        经典面试题一：输出结果为？
            int a = 8;
            int b = (a++)+(++a)+(a*10);
            //a = 10
            //b = 8 + 10 + 10*10
            System.out.println(b);
            
        经典面试题二：输出结果为？
            int i = 0 ;   
            //底层实现：
            // i = (int)(i+1);
            // i = i;
            i = ++i; 
            System.out.println(i);//1
            
        经典面试题三：输出结果为？
            int i = 0;   
            //底层实现：
            // int temp = i;//temp作为临时变量，记录了i最初始的值 -- 0
            // i = (int)(i+1);//i确确实实自增了-- 1
            // i = temp;//将temp赋值给i -- 0
            i = i++;  
            System.out.println(i);//0

二、赋值运算符

符号	作用
=	右边的值赋值给左边的变量
+=	左边变量的值加上右边的值再赋值给左边的变量
-=	左边变量的值减去右边的值再赋值给左边的变量
*=	左边变量的值乘以右边的值再赋值给左边的变量
/=	左边变量的值除以右边的值再赋值给左边的变量
%=	将左边变量的值除以右边的值的余数 赋值给左边的变量

    int num = 10;
    
    num += 5;//num = (int)(num+5)-->num = 15;
    num -= 5;//num = (int)(num-5)-->num = 10;
    num *= 5;//num = (int)(num*5)-->num = 50;
    num /= 5;//num = (int)(num/5)-->num = 10;
    num %= 3;//num = (int)(num%3)-->num = 1;
    
    System.out.println(num);
    
    经典面试题一：输出结果为？
        int a,b; //一次性声明多个变量
        a = b = 100;//将100赋值给b，再将b赋值给a
        System.out.println(a); //100
        System.out.println(b); //100
        
    经典面试题二：下面的两种写法结果分别是？
        short s=1; 
        s = s+1; //short和int做运算会向上转型成int，如果没有强转就会报错
​
        short s=1; 
        s += 1;
        
    赋值规则：
                 s   += 1                s  = (short)((s)  +    (1))
        复合赋值 E1 op= E2等价于简单赋值 E1 = (T)((E1) op  (E2))，其中T是E1的类型。

三、关系运算符

符号	作用
==	判断左右变量的值是否相等
!=	判断左右变量的值是否不相等
>	判断左边变量的值是否大于右边变量的值
>=	判断左边变量的值是否大于等于右边变量的值
<	判断左边变量的值是否小于右边变量的值
<=	判断左边变量的值是否小于等于右边变量的值

注意：关系运算符的结果必须是boolean！！！

        boolean bool = 10 == 20;
        System.out.println(bool);//false
        System.out.println(10 != 20);//true
        System.out.println(10 >  20);//false
        System.out.println(10 >= 20);//false
        System.out.println(10 <  20);//true
        System.out.println(10 <= 20);//true
        
        经典面试题一：输出结果为？
            int x = 10;
            int y = 10;
            boolean flag = (x == y);
            System.out.println(flag);//true
            flag = (x = y);//会报错 -- 因为boolean类型不能与其他类型兼容
            System.out.println(flag);
            
        经典面试题二：输出结果为？
            boolean b1 = true;
            boolean b2 = false;
            boolean b3 = (b1 == b2);
            System.out.println(b3);//false
            boolean b4 = (b1 = b2);
            System.out.println(b4);//false

四、逻辑运算符

注意：逻辑运算符两边都是boolean类型的值；&左边为false时依然会判断右边，| 左边为true时依然会判断右边

符号	作用
&	两侧都为true，结果才为true
&&	两侧都为true，结果才为true
|	有一侧为true,结果为true
||	有一侧为true,结果为true
^	两侧相同结果为false,不同为true
!	对当前布尔值取反

        //&与：前后两侧都是boolean值，两侧都为true，结果才为true
        System.out.println(true & true);//true
        System.out.println(false & true);//false
​
        //&&短路与：前后两侧都是boolean值，两侧都为true，结果才为true
        System.out.println(true && true);//true
        System.out.println(false && true);//false   
​
        //& vs &&
        //&与：判断前者为false后，还会判断后者
        //&&短路与：判断前者为false后，不会判断后者，直接返回false，所以效率更高
        //ArithmeticException - 算数异常
        System.out.println(false && 10/0>3);
​
        //|或：前后两侧都是boolean值，两侧有为true，结果就为true
        System.out.println(true | true);//true
        System.out.println(false | true);//true
        System.out.println(true | false);//true 
​
        //||短路或：前后两侧都是boolean值，两侧有为true，结果就为true
        System.out.println(true || true);//true
        System.out.println(false || true);//true
        System.out.println(true || false);//true
        
        //| vs ||
        //|或：判断前者为true后，还会判断后者
        //||短路或：判断前者为true后，不会判断后者，直接返回true，所以效率更高
        System.out.println(true || 10/0>3);
        
        //^异或：前后两侧都是boolean值，两侧相同为false，不同为true
        System.out.println(false ^ true);//true
        System.out.println(false ^ false);//false
        
        //!非：置反
        boolean bool1 = true;
        System.out.println(!bool1);//false
        
        boolean bool2 = false;
        System.out.println(!bool2);//true

五、三目运算符/三元运算符

语法规则: 变量 = (表达式)?值1:值2;

知识点：表达式 5+6 算数表达式；5>6 关系表达式

理解：表达式的结果必须是boolean值 true - 将值1赋值给变量 false- 将值2赋值给变量

        int num = (false)?10:20;
        System.out.println(num);//20
        num = (true)?10:20;
        System.out.println(num);//10
​
        案例：在控制台输入三个int类型的数据，判断大小，由小到大输出
            Scanner scan = new Scanner(System.in);
        
            System.out.println("请输入第一个数字：");
            int a = scan.nextInt();
            System.out.println("请输入第二个数字：");
            int b = scan.nextInt();
            System.out.println("请输入第三个数字：");
            int c = scan.nextInt();
            
            //最大值
            int max = (a>b)?a:b;
            max = (max>c)?max:c;
            
            //最小值
            int min = (a<b)?a:b;
            min = (min<c)?min:c;
            
            //中间值
            int mid = a+b+c-max-min;
            
            System.out.println(min + "<" + mid + "<" + max);
        

三目运算符返回值规则： 1.值1和值2都是常量的情况，按照取值范围大的类型返回数据(常量：在程序执行过程中，不可发生改变的量,数字字面量就是常量的一种) 2.值1和值2都是变量的情况，按照取值范围大的类型返回数据 3.值1和值2一个是常量一个是变量的情况，判断常量是否在变量所属类型的取值范围里 在 - 按照变量类型返回数据 不在-按照常量类型返回数据

        扩展面试题1
        System.out.println((false)?10.9:9);//9.0
            
        扩展面试题2：
            char x = 'x';//码值 - 120
            int i = 10;
            System.out.println(false?i:x);//120
            
        扩展面试题3：
            char x = 'x';//码值 - 120
            System.out.println(false?100:x);//x
            System.out.println(false?100000:x);//120

六、位运算符

符号	作用
&	同位比较，两者为1，结果才为1
|	同位比较，两者有1，结果就为1
^	同位比较，两者不同为1，相同为0
<<	整体向左移动n位，就用n个0补位(补到最低位)，左移一位相等于乘2
>>	整体向右移动n位，就用n个最高位/符号位补位(补到最高位)，右移一位相等于除以2
>>>	整体向右移动n位，就用n个最高位/符号位补位(补到最高位)

注意： &、|、^前后两侧是数值，该符号为位运算符 &、|、^前后两侧是布尔值，该符号为逻辑运算符

        //&与：同位比较，两者为1，结果才为1
        byte b1 = 19;
        byte b2 = 21;       
        //b1 - byte：0001,0011
        //      int：0000,0000,0000,0000,0000,0000,0001,0011
        //b2 - byte：0001,0101
        //      int：0000,0000,0000,0000,0000,0000,0001,0101
​
        //result   ：0000,0000,0000,0000,0000,0000,0001,0001
        //result - byte：                          0001,0001
        byte result = (byte)(b1 & b2);
        System.out.println(result);//17 - 0001,0001
        
        //|或：同位比较，两者有1，结果就为1
        int i1 = 19;//0000,0000,0000,0000,0000,0000,0001,0011
        int i2 = 21;//0000,0000,0000,0000,0000,0000,0001,0101
                    //0000,0000,0000,0000,0000,0000,0001,0111
        System.out.println(i1 | i2);//23
        
        //^异或：同位比较，两者不同为1，相同为0
        int i1 = 19;//0000,0000,0000,0000,0000,0000,0001,0011
        int i2 = 21;//0000,0000,0000,0000,0000,0000,0001,0101
                    //0000,0000,0000,0000,0000,0000,0000,0110
        System.out.println(i1 ^ i2);//6
​
​
            
        //<<左移：整体向左移动n位，就用n个0补位(补到最低位)
        //注意：左移一位相等于乘2
        int i = 1024;//0000,0000,0000,0000,0000,0100,0000,0000
                     //0000,0000,0000,0000,0001,0000,0000,0000
        System.out.println(i << 2);//4096
        
        //>>右移：整体向右移动n位，就用n个最高位/符号位补位(补到最高位)
        //注意：右移一位相等于除2
        int a = 1024;//0000,0000,0000,0000,0000,0100,0000,0000
                     //0000,0000,0000,0000,0000,0001,0000,0000
        System.out.println(a >> 2);//256
        int b = -1024;//1111,1111,1111,1111,1111,1100,0000,0000
                      //1111,1111,1111,1111,1111,1111,0000,0000
        System.out.println(b >> 2);//-256
        
        //>>>无符号位右移：整体向右移动n位，就用n个0补位(补到最高位)
        //注意：>>和>>>在处理正数的情况下没有区别
        int c = 1024;//0000,0000,0000,0000,0000,0100,0000,0000
                     //0000,0000,0000,0000,0000,0001,0000,0000
        System.out.println(c >> 2);//256
        int d = -1024;//1111,1111,1111,1111,1111,1100,0000,0000
                      //0011,1111,1111,1111,1111,1111,0000,0000
        System.out.println(d >>> 2);//1073741568
        
        面试题：描述下列代码运行结果
        考点：char类型的取值范围没有负数，向上转型是用0补位
        //-1 - int：1111,1111,1111,1111,1111,1111,1111,1111
        //    byte：1111,1111
        //    char：1111,1111,1111,1111
        //     int：0000,0000,0000,0000,1111,1111,1111,1111
        System.out.println((int)(char)(byte)-1);//65535