03-01 Java运算符

(1)算术运算符

        A:+,-,*,/,%,++,--
        B:+的用法
            a:加法
            b:正号
            c:字符串连接符
        C:/和%的区别
            数据做除法操作的时候，/取得是商，%取得是余数
        D:++和--的用法
            a:他们的作用是自增或者自减
            b:使用
                **单独使用
                    放在操作数据的前面和后面效果一样。
                    a++或者++a效果一样。
                **参与操作使用
                    放在操作数的前面：先自增或者自减，再参与操作
                        int a = 10;
                        int b = ++a;
                    放在操作数的后面：先参与操作，再自增或者自减
                        int a = 10;
                        int b = a++;

/和%的区别：

/*
    注意事项：
        A:整数相除只能得到整数。如果想得到小数，必须把数据变化为浮点数类型
        B:/获取的是除法操作的商，%获取的是除法操作的余数
*/

class OperatorDemo {
    public static void main(String[] args) {
        //定义变量
        int x = 3;  //把3赋值给int类型的变量x
        int y = 4;
        
        System.out.println(x+y);
        System.out.println(x-y);
        System.out.println(x*y);
        System.out.println(x/y); //得到0，整数相除只能得到整数
        
        //我就想得到小数，该肿么办呢?
        //只需要把操作的数据中任意的一个数据变为浮点数
        System.out.println(x*1.0/y);
        
        //%的应用
        System.out.println(x%y); //得到的是余数
    }
}

++,--运算符的使用;

/*
    ++,--运算符的使用：
        单独使用：
            放在操作数的前面和后面效果一样。(这种用法是我们比较常见的)
        参与运算使用：
            放在操作数的前面，先自增或者自减，然后再参与运算。
            放在操作数的后面，先参与运算，再自增或者自减。
            
    作用：就是对变量进行自增1或者自减1。
*/
class OperatorDemo2 {
        public static void main(String[] args) {
            //定义两个变量
            int x = 3;
            int y = 4;
            
            //字符串的拼接，字符串在前面
            //System.out.println("x:"+x);
            //System.out.println("y:"+y);
            
            System.out.println("x:"+x+",y:"+y);
            
            //单独使用
            //x++;
            //y--;
            ++x;
            --y;
            //System.out.println(x);
            System.out.println("x:"+x+",y:"+y);
            
            //意外的类型,常量是不可以这样做的
            //System.out.println(10++);
            
            System.out.println("-------------------");
            //参与运算使用
            int a = 3;
            int b = 4;
            
            //int c = a++;
            //int d = b--;
            
            int c = ++a; //++放在操作数前面，先自增或者自减，然后再赋值
            int d = --b;
            
            System.out.println("a:"+a); //4, 4
            System.out.println("b:"+b); //3, 3
            System.out.println("c:"+c); //3, 4
            System.out.println("d:"+d); //4, 3
        }
}

运算符的优先级：

 +的用法：

/*
    +的用法：
        A:加法
        B:正号
        C:字符串连接符
*/
class OperatorDemo3 {
    public static void main(String[] args) {
        //加法
        System.out.println(3+4);
        
        //正号
        System.out.println(+4);
        
        System.out.println('a');//直接输出字符a
        System.out.println('a'+1); //字符a和1的加法，这里是加法输出98
        
        //字符串连接符，注意是字符串而不是字符
        System.out.println("hello"+'a'+1);//helloa1，字符串hello和字符a链接，得到字符串helloa，再和链接
        System.out.println('a'+1+"hello");//98hello，先进行字符a和1的加法运算，再和字符串hello链接
        
    }
}

(2)赋值运算符

(2)赋值运算符
        A:=,+=,-=,*=,/=,%=等
        B:=叫做赋值运算符，也是最基本的赋值运算符
            int x = 10; 把10赋值给int类型的变量x。
        C:扩展的赋值运算符的特点
            隐含了自动强制转换。
            
            例子：
                short s = 1;
                s = s + 1;
                
                short s = 1;
                s += 1;
                请问上面的代码哪个有问题?

赋值运算符：

/*
    赋值运算符：
        基本的赋值运算符：=
            把=右边的数据赋值给左边。
            
        扩展的赋值运算符：+=,-=,*=,/=,%=
            += 把左边和右边做加法，然后赋值给左边。
*/
class OperatorDemo {
    public static void main(String[] args) {
        //定义一个变量
        int x = 10;
        
        //其他用法
        int a,b; 
        a = b = 10;//把10赋给b,再把b赋值给a。这种写法不建议
        System.out.println(a); 
        System.out.println(b);
        System.out.println("-----------");

        //定义一个变量
        int y = 10;
        
        y += 20;//y = y + 20
        
        System.out.println(y);
        
    }
}

扩展的赋值运算符其实隐含了一个强制类型转换：

/*
   
        short s=1;s = s+1; 
        
        short s=1;s+=1;
        上面两个代码有没有问题，如果有，那里有问题。
        
        为什么第二个木有问题呢?
            扩展的赋值运算符其实隐含了一个强制类型转换。
            
            s += 1;
            不是等价于 s = s + 1;
            而是等价于 s = (s的数据类型)(s + 1);
*/
class OperatorTest {
    public static void main(String[] args) {
        //short s = 1;
        //s = s + 1;
        //System.out.println(s);
        //s = s + 1;//short类型，先转成int,和1相加，再赋值给short类型，报错
        short s = 1;
        s += 1; //好像是 s = s + 1;
        System.out.println(s);
    }
}

(3)比较运算符

/*
    比较运算符：
        ==,!=,>,>=,<,<=
        
    特点：
        无论你的操作是简单还是复杂，结果是boolean类型。
        
    注意事项：
        "=="不能写成"="。
*/
class OperatorDemo {
    public static void main(String[] args) {
        int x = 3;
        int y = 4;
        int z = 3;
    
        System.out.println(x == y);
        System.out.println(x == z);
        System.out.println((x+y) == (x+z));
        System.out.println("------------");
        
        System.out.println(x != y);
        System.out.println(x > y);
        System.out.println(x >= y);
        System.out.println(x < y);
        System.out.println(x <= y);
        System.out.println("------------");
        
        int a = 10;
        int b = 20;
        
        //boolean flag = (a == b);
        //boolean flag = (a = b); //这个是有问题的，不兼容的类型。
        //把b赋值给a，然后把a留下来，而a是int类型，赋值给flag的布尔类型，报错
        //System.out.println(flag);
        
        int c = (a = b); //把b赋值给a，然后把a留下来，而a是int类型，赋值给flag的布尔类型，出错
        System.out.println(c);

(4)逻辑运算符

        A:&,|,^,!,&&,||
        B:逻辑运算符用于连接boolean类型的式子
        C:结论
            &:有false则false
            |:有true则true
            ^:相同则false，不同则true。
                情侣关系。
            !:非true则false，非false则true
            
            &&:结果和&是一样的，只不过有短路效果。左边是false，右边不执行。
            ||:结果和|是一样的，只不过有短路效果。左边是true，右边不执行。

/*
    逻辑运算符：
        &,|,^,!
        &&,||
        
    特点：
        逻辑运算符一般用于连接boolean类型的表达式或者值。
            
        表达式：就是用运算符把常量或者变量连接起来的符合java语法的式子。
            算术表达式：a + b
            比较表达式：a == b
            
    结论：
        &逻辑与:有false则false。
        |逻辑或:有true则true。
        ^逻辑异或:相同为false，不同为true。
            举例：情侣关系。男男,男女,女男,女女
        !逻辑非:非false则true，非true则false。
            特点：偶数个不改变本身。
*/
class OperatorDemo {
    public static void main(String[] args) {
        int a = 3;
        int b = 4;
        int c = 5;
        
        //&逻辑与
        System.out.println((a > b) & (a > c)); //false & false = false
        System.out.println((a > b) & (a < c)); //false & true = false
        System.out.println((a < b) & (a > c)); //true & false = false
        System.out.println((a < b) & (a < c)); //true & true = true
        System.out.println("---------------");
        
        //|逻辑或
        System.out.println((a > b) | (a > c)); //false | false = false
        System.out.println((a > b) | (a < c)); //false | true = true
        System.out.println((a < b) | (a > c)); //true | false = true
        System.out.println((a < b) | (a < c)); //true | true = true
        System.out.println("---------------");
        
        //^逻辑异或
        System.out.println((a > b) ^ (a > c)); //false ^ false = false
        System.out.println((a > b) ^ (a < c)); //false ^ true = true
        System.out.println((a < b) ^ (a > c)); //true ^ false = true
        System.out.println((a < b) ^ (a < c)); //true ^ true = false
        System.out.println("---------------");
        
        //!逻辑非
        System.out.println(!(a > b)); //!false = true
        System.out.println(!(a < b)); //!true = false
        System.out.println(!!(a > b)); //!!false = false
        System.out.println(!!!(a > b)); //!!false = true
    }
}

&&和&的区别? 同理||和|的区别?

/*
    &&和&的区别? 同理||和|的区别?
        A:最终结果一样。
        B:&&具有短路效果。左边是false，右边不执行。
        
    开发中常用的逻辑运算符：
        &&,||,!
*/
class OperatorDemo2 {
    public static void main(String[] args) {
        int a = 3;
        int b = 4;
        int c = 5;
        
        //&&双与
        System.out.println((a > b) && (a > c)); //false && false = false
        System.out.println((a > b) && (a < c)); //false && true = false
        System.out.println((a < b) && (a > c)); //true && false = false
        System.out.println((a < b) && (a < c)); //true && true = true
        System.out.println("----------------");
        
        int x = 3;
        int y = 4;
        
        //boolean b1 = ((x++ == 3) & (y++ == 4));
        //boolean b1 = ((x++ == 3) && (y++ == 4));
        //boolean b1 = ((++x == 3) & (y++ == 4));
        boolean b1 = ((++x == 3) && (y++ == 4));
        System.out.println("x:"+x);
        System.out.println("y:"+y);
        System.out.println(b1);
    }
}

 位运算

(5)位运算符(了解)
        A:^的特殊用法
            一个数据针对另一个数据位异或两次，该数不变
        B:实例
            a:请实现两个变量的交换
                **采用第三方变量
                **用位异或运算符
                    左边a,b,a
                    右边a^b
            b:请用最有效率的方式计算出2乘以8的结果
                2<<3

位运算符：&,|,^,~ 解释

/*
    位运算符：
        &,|,^,~
        <<,>>,>>>
        
    注意：
        要做位运算，首先要把数据转换为二进制。
*/
class OperatorDemo {
    public static void main(String[] args) {
        //&,|,^,~
        
        int a = 3;
        int b = 4;
        
        System.out.println(3 & 4);//当&两边是数据，做的是位运算；当&两边是布尔值，做的是逻辑运算
        System.out.println(3 | 4);
        System.out.println(3 ^ 4);
        System.out.println(~3);
    }
}
/*
    分析：因为是位运算，所以我们必须先把数据换算成二进制。
    
    3的二进制：11
        00000000 00000000 00000000 00000011
    4的二进制：100
        00000000 00000000 00000000 00000100
    
    &位与运算：有0则0。
        00000000 00000000 00000000 00000011
       &00000000 00000000 00000000 00000100
        -----------------------------------
        00000000 00000000 00000000 00000000
        结果是：0
        
    |位或运算：有1则1。
        00000000 00000000 00000000 00000011
       |00000000 00000000 00000000 00000100
        -----------------------------------
        00000000 00000000 00000000 00000111
        结果是：7
        
    ^位异或运算：相同则0，不同则1。
        00000000 00000000 00000000 00000011
       &00000000 00000000 00000000 00000100
        -----------------------------------
        00000000 00000000 00000000 00000111
        结果是：7
        
    ~按位取反运算符：0变1，1变0，针对补码
    在计算机内，有符号数有3种表示法：原码、反码和补码。所有数据的运算都是采用补码进行的。
    原码：就是二进制定点表示法，即最高位为符号位，“0”表示正，“1”表示负，其余位表示数值的大小。
    反码：
        正数的反码与其原码相同；负数的反码是对其原码逐位取反，但符号位除外。
    补码
        正数的补码与其原码相同；负数的补码是在其反码的末位加1。
        
        00000000 00000000 00000000 00000011  //正数的原码、反码、补码相同，这里代表3的补码
       ~11111111 11111111 11111111 11111100 (补码) ~3  按位对3的补码取反得到的
       
       //下面通过补码，求得原码
       补码：11111111 11111111 11111111 11111100
       反码：11111111 11111111 11111111 11111011
       原码：10000000 00000000 00000000 00000100
        结果是：-4
*/

^异或的特点：一个数据对另一个数据位异或两次，该数本身不变。

/*
    ^的特点：一个数据对另一个数据位异或两次，该数本身不变。
    比如b对a异或两次，a数本身不变。
    可以用来简单加密
*/
class OperatorDemo2 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        
        System.out.println(a ^ b ^ b); //10
        System.out.println(a ^ b ^ a); //20
    }
}

实现两个整数变量的交换：

/*
    实例：
        实现两个整数变量的交换

*/
class OperatorTest {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        
        System.out.println("a:"+a+",b:"+b);
        
        //方式1：使用第三方变量(开发中用的)
        /*
        int c = a;
        a = b;
        b = c;
        System.out.println("a:"+a+",b:"+b);
        System.out.println("------------");
        */
        
        //方式2：用位异或实现(面试用)
        //左边：a,b,a
        //右边：a ^ b
        /*
        a = a ^ b;
        b = a ^ b; //a ^ b ^ b = a
        a = a ^ b; //a ^ b ^ a = b
        System.out.println("a:"+a+",b:"+b);
        */
        
        //方式3：用变量相加的做法
        /*
        a = a + b; //a=30，先把和保存
        b = a - b; //b=10，
        a = a - b; //a=20
        System.out.println("a:"+a+",b:"+b);
        */
        
        //方式4：一句话搞定
        b = (a+b) - (a=b); //b=30-20=10,a=20  //先把b赋值给a，然后用和减去a得到b
        System.out.println("a:"+a+",b:"+b);
    }
}

位移运算 

/*
    <<:左移    左边最高位丢弃，右边补齐0
    >>:右移    最高位是0，左边补齐0；最高为是1，左边补齐1
    >>>:无符号右移 无论最高位是0还是1，左边补齐0
    
    
        请用最有效率的方式写出计算2乘以8的结果?
            2 * 8
            
            2 << 3

*/
class OperatorDemo3 {
    public static void main(String[] args) {
        //<< 把<<左边的数据乘以2的移动次幂
        System.out.println(3 << 2); //3*2^2 = 3*4 = 12;
    
        //>> 把>>左边的数据除以2的移动次幂
        System.out.println(24 >> 2); //24 / 2^2 = 24 / 4 = 6
        
        System.out.println(24 >>> 2);
        
        System.out.println(-24 >> 2); 
        System.out.println(-24 >>> 2);
    }
}
/*
    计算出3的二进制：11
        00000000 00000000 00000000 00000011
    (00)000000 00000000 00000000 0000001100
        
    >>的移动：    
    计算出24的二进制：11000
     -24原码：10000000 00000000 00000000 00011000
        反码：11111111 11111111 11111111 11100111
        补码：11111111 11111111 11111111 11101000
        
        //>>:右移    最高位是0，左边补齐0；最高为是1，左边补齐1
        11111111 11111111 11111111 11101000
        1111111111 11111111 11111111 111010(00) 补码
        
        //将补码转成原码
        补码：1111111111 11111111 11111111 111010
        反码：1111111111 11111111 11111111 111001
        原码：1000000000 00000000 00000000 000110
        
        结果：-6
        
    >>>的移动：
        计算出24的二进制：11000
        原码：10000000 00000000 00000000 00011000
        反码：11111111 11111111 11111111 11100111
        补码：11111111 11111111 11111111 11101000
        
        11111111 11111111 11111111 11101000
        0011111111 11111111 11111111 111010(00)//这里原、反、补都相同
        
        结果：
*/

三目运算

/*
    单目运算符：~3
    双目运算符：3 + 4

    三目运算符：
        格式：比较表达式?表达式1:表达式2;
        
        比较表达式:结果是一个boolean类型。
        
        执行流程：
            根据比较表达式的计算返回一个true或者false。
            如果是true，就把表达式1作为结果。
            如果是false，就把表达式2作为结果。
*/
class OperatorDemo {
    public static void main(String[] args) {
        int x = 100;
        int y = 200;
        
        int z = ((x > y)? x: y);
        
        //int z = ((x < y)? x: y);
        
        //int z = ((x == y)? x: y);
        
        //报错
        //int z = ((x = y)? x : y);//表达式是布尔类型，才能判断。这里把y赋值给x，而x是int类型
        
        System.out.println("z:"+z);
    }
}

获取最大值，判断值是否相等

/*
    练习：
        获取两个整数中的最大值
        获取三个整数中的最大值
        比较两个整数是否相同
*/
class OperatorTest {
    public static void main(String[] args) {
        //获取两个整数中的最大值
        int x = 100;
        int y = 200;
        
        int max = (x > y? x: y);
        System.out.println("max:"+max);
        System.out.println("--------");
        
        //获取三个整数中的最大值
        int a = 10;
        int b = 30;
        int c = 20;
        
        //分两步：
        //A:先比较a,b的最大值
        //B:拿a,b的最大值在和c进行比较
        int temp = ((a > b)? a: b);
        //System.out.println(temp);
        int max1 = (temp > c? temp: c);
        System.out.println("max1:"+max1);
        
        //一步搞定
        //int max2 = (a > b)?((a > c)? a: c):((b > c)? b: c);
        //这种做法不推荐。
        
        //int max2 = a > b?a > c? a: c:b > c? b: c;
        //System.out.println("max2:"+max2);
        System.out.println("--------");
        
        //比较两个整数是否相同
        int m = 100;
        int n = 200;
        
        //boolean flag = (m == n)? true: false;
        boolean flag = (m == n);
        System.out.println(flag);
    }
}