JAVA学习笔记二之(6)运算符②

最新推荐文章于 2024-07-24 16:23:15 发布

Lucky_Light

最新推荐文章于 2024-07-24 16:23:15 发布

阅读量479

点赞数

分类专栏： JAVASE学习文章标签： java

本文链接：https://blog.csdn.net/Celelong/article/details/51483617

版权

JAVASE学习专栏收录该内容

13 篇文章 0 订阅

订阅专栏

JAVA学习笔记二之(6)运算符②

一、比较运算符

　　１、比较运算符：
　　　　==，!=，>，<，>=，<=，instanceof（后面讲）
　　　　
　　２、特点：
　　　　比较运算符的结果肯定是boolean类型。
　　　　
　　３、注意：
　　　　请注意==和=的区别。
　　　　
　　４、运算符的优先级：
　　　　java中的运算符也是有优先级的。
　　　　如果你怕不好理解，那么就加小括号。

class OperatorDemo1 {
    public static void main(String[] args) {
        //在一行上声明多个变量，用逗号隔开是可以的。但是不推荐。
        //int a, b;
        //a = 10;
        //b = 20;

        //推荐在一行上只声明或者定义一个变量。
        //变量什么时候用，就什么时候定义。
        int a = 10;
        int b = 20;
        int c = 10;

        //下面这种写法不是语句。
        //a==b;
        //a==c;

        //下面这种写法就可以
        boolean flag = (a == b);
        System.out.println(flag);
        System.out.println(a==b);

        System.out.println("-----------");

        System.out.println(a>b);
        System.out.println(a>c);

        System.out.println("-----------");

        System.out.println(a>=b);
        System.out.println(a>=c);

        System.out.println("-----------");

        System.out.println(a!=b);
        System.out.println(a!=c);

        System.out.println("-----------");

        System.out.println((a+b-c) == (a-b+c));

        System.out.println("-----------");

        System.out.println(a==b); //false
        System.out.println(a=b); //20。把b的值赋值给a，留下a输出。

        //不兼容类型。
        //右边最终的结果是int类型
        //左边boolean类型。这种赋值是有问题的。

        //boolean flag2 = (a=b);
        //System.out.rintln(flag2); //20
    }
}

二、逻辑运算符

　　１、逻辑运算符：
　　　　&，|，^，!
　　　　&&，||
　　　　
　　２、&逻辑运算符：有false则false。
　　
　　３、|逻辑运算符：有true则true。
　　
　　４、^逻辑运算符：相同为false，不同为true。
　　　　情侣：男女，女男。
　　　　不是情侣：男男，女女。
　　　　
　　５、!逻辑运算符：非真即假，非假即真。
　　　　　　偶数个！不改变原始真假。

class OperatorDemo2 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 30;

        //boolean f1 = (a > b) & (a > c);
        //System.out.println(f1);

        //&运算符
        System.out.println((a > b) & (a > c)); //false & false = false 
        System.out.println((b > a) & (a > c)); //true & false = false
        System.out.println((a > b) & (c > a)); //false & true = false
        System.out.println((b > a) & (c > a)); //true & true = true

        System.out.println("-----------");

        //|运算符
        System.out.println((a > b) | (a > c)); //false | false = false 
        System.out.println((b > a) | (a > c)); //true | false = true
        System.out.println((a > b) | (c > a)); //false | true = true
        System.out.println((b > a) | (c > a)); //true | true = true

        System.out.println("-----------");

        //^运算符
        System.out.println((a > b) ^ (a > c)); //false ^ false = false 
        System.out.println((b > a) ^ (a > c)); //true ^ false = true
        System.out.println((a > b) ^ (c > a)); //false ^ true = true
        System.out.println((b > a) ^ (c > a)); //true ^ true = false

        System.out.println("-----------");

        //！运算符
        System.out.println(a > b); //false
        System.out.println(!(a > b)); //true
        System.out.println(!!(a > b)); //false
        System.out.println(!!!(a > b)); //true
        System.out.println(!!!!(a > b)); //false
    }
}

　　６、&&和&，以及||和|的区别：
　　　　&&：具有断路效果。如果左边是false，右边将不再执行。　　　　　
　　　　||：具有断路效果。如果左边是true，右边将不再执行。
　　　　
　　　　开发中常用的逻辑运算符：
　　　　　　&&，||，!

class OperatorDemo3 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 30;

        //&运算符
        System.out.println((a > b) & (a > c)); //false & false = false 
        System.out.println((b > a) & (a > c)); //true & false = false
        System.out.println((a > b) & (c > a)); //false & true = false
        System.out.println((b > a) & (c > a)); //true & true = true

        System.out.println("---------------");

        //&&运算符
        System.out.println((a > b) && (a > c)); //false && false = false 
        System.out.println((b > a) && (a > c)); //true && false = false
        System.out.println((a > b) && (c > a)); //false && true = false
        System.out.println((b > a) && (c > a)); //true && true = true

        System.out.println("---------------");

        int x = 3;
        int y = 4;
        int z = 5;

        System.out.println((x++ > 4) & (y++ > 5)); 
        System.out.println("x：" + x); //x:4
        System.out.println("y：" + y); //y:5

        System.out.println("---------------");

        System.out.println((x++ > 4) && (y++ > 5)); 
        System.out.println("x：" + x); //x:4
        System.out.println("y：" + y); //y:4
    }
}

三、位运算符

　　１、位运算符：
　　　　&，|，^，~
　　　　<<，>>，>>>
　　　　
　　　　位运算符进行的操作都是二进制的。也就是说，我们要把数据转换成二进制的。
　　　　
　　２、&，|，^，~的使用

class OperatorDemo4 {
    public static void main(String[] args) {
        int a = 3;
        int b = 4;

        System.out.println(3 & 4); //0
        System.out.println(3 | 4); //7
        System.out.println(3 ^ 4); //7
        System.out.println(~3); //-4
    }
}

　　分析：

　　3的二进制：
　　　　00000000 00000000 00000000 00000011
　　4的二进制：
　　　　00000000 00000000 00000000 00000100

位&运算符：按位与运算符，有0则0。
     00000000 00000000 00000000 00000011
    &00000000 00000000 00000000 00000100
    ------------------------------------
     00000000 00000000 00000000 00000000

位|运算符：按位或运算符，有1则1。
     00000000 00000000 00000000 00000011
    |00000000 00000000 00000000 00000100
    ------------------------------------
     00000000 00000000 00000000 00000111

位^运算符：按位异或运算符，相同则0，不同则1。
     00000000 00000000 00000000 00000011
    ^00000000 00000000 00000000 00000100
    ------------------------------------
     00000000 00000000 00000000 00000111

位~运算符：按位取反运算符。也就是1变0，0变1。
     00000000 00000000 00000000 00000011
   ~ 11111111 11111111 11111111 11111100 补码
     11111111 11111111 11111111 11111011 反码
     10000000 00000000 00000000 00000100 原码

　　３、<<，>>，>>>的使用
　　　　<<：相当于乘以2的移动位数次幂。
　　　　>>：相当于除以2的移动位数次幂。
　　　　>>>：相当于除以2的移动位数次幂。

class OperatorDemo5 {
    public static void main(String[] args) {
        int a = 16;

        System.out.println(a << 2); //64
        System.out.println(a >> 2); //4
        System.out.println(a >>> 2); //4
    }
}

　　分析：

　　16的二进制：
　　　　00000000 00000000 00000000 00010000

<<运算符：左移运算符，把数据往左边移动右边指定的位数。移出的位置用0补齐。
    00000000 00000000 00000000 00010000
(00)00000000 00000000 00000000 01000000

>>运算符：右移运算符，把数据往右边移动右边指定的位数。移出的位置用最高位的数值补齐。
    00000000 00000000 00000000 00010000
    00000000 00000000 00000000 00000100(00)

>>>运算符：无符号右移运算符，把数据往右边移动右边指定的位数。移出的位置用0补齐。
    00000000 00000000 00000000 00010000
    00000000 00000000 00000000 00000100(00)

　　面试题：
　　　　请用最有效率的方式计算出2乘以8。
　　　　　　2 << 3。

　　４、按位异或
　　　　(1)、按位异或运算符的特点：
　　　　　　对同一个数据异或偶数次，该数据本身不变。
　　　　　　
　　　　(2)、应用：
　　　　　　对数字加密。
　　　　　　
　　　　(3)、题目：
　　　　　　需求：我有a，b两个变量，请把a与b的两个值进行交换。
　　　　　　　　　int a = 10;
　　　　　　　　　int b = 20;
　　　　　　结果：
　　　　　　　　　a = 20;
　　　　　　　　　b = 10;
　　　　　　代码：

class OperatorDemo6 {
    public static void main(String[] args) {
        int a = 3;
        int b = 4;

        System.out.println(a); //3 
        System.out.println(a ^ b); //7
        System.out.println(a ^ b ^ b); //3
    }
}

　　５、交换两个变量值的多种方式

class OperatorDemo7 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;

        //方式1：
        //int temp = a;
        //a = b;
        //b = temp;
        //System.out.println(a + "---" + b);

        //方式2：
        //a = a ^ b;
        //b = a ^ b; //a ^ b = a ^ b ^ b = a;
        //a = a ^ b; //a ^ b = a ^ b ^ a = b;
        //System.out.println(a + "---" + b);

        //方式3：
        //a = a + b;
        //b = a - b;
        //a = a - b;
        //System.out.println(a + "---" + b);

        //方式4：一句话实现。
        a = (a + b) - (b = a);
        System.out.println(a + "---" + b);
    }
}

四、三元运算符

　　１、表达式
　　　　用运算符把变量和常量连接起来的式子。
　　　　举例：
　　　　　　算术表达式：a+b;
　　　　　　赋值表达式：a=10;

　　２、三元运算符
　　　　(1)、格式：
　　　　　　(条件表达式) ? 值1 : 值2;
　　　　　　条件表达式的结果是boolean类型。
　　　　(2)、三元运算符的执行顺序：
　　　　　　看比较表达式的值是true还是false。
　　　　　　如果是true，就把值1作为结果。
　　　　　　如果是false，就把值作为结果。

class OperatorDemo8 {
    public static void main(String[] args) {
        int a = 100;
        int b = 200;

        //获取两个数中的最大值。
        int c = (a > b) ? a : b;
        System.out.println(c);
    }
}

　　３、举例
　　　　A：获取三个数中的最大值。
　　　　　　提示：以后我再说数据的时候，如果没有说数据类型，默认是int类型。
　　　　B：判断两个数据是否相等。
　　　　
　　　　分析A：
　　　　　　a：定义3个int类型的变量。
　　　　　　b：先比较前两个数据，获取到最大值。
　　　　　　c：把前两个的最大值和第三个数据进行比较。得到最大值。
　　　　分析B：
　　　　　　a：定义两个int类型的变量。
　　　　　　b：用比较运算符比较即可。

class OperatorDemo9 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 30;

        //先比较前两个数据，获取到最大值。
        int temp = (a > b) ? a : b;

        //把前两个的最大值和第三个数据进行比较。得到最大值。
        int max1 = (temp > c) ? temp : c;
        System.out.println(max1);

        //合并写法
        int max2 = a > b ? (a > c ? a : c) : (b > c ? b : c);
        System.out.println(max2);

        System.out.println("--------------");

        //定义两个int类型的变量。
        int x = 10;
        int y = 20;

        //用比较运算符比较即可。
        //boolean flag = (x == y) ? true : false;
        boolean flag = (x == y);
        System.out.println(flag);
    }
}