java--运算符

运算符是一种特殊的符号，用于表示数据的运算、赋值和比较等等。
运算符的优先等级
1）运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序，运算顺序上一行的运算符总优先于下一行

                    . () {} ; ,
        R->L        ++ -- ~ !(data type)
        L->R        * / %
        L->R        + -
        L->R        << >> >>>
        L->R        < > <= >= instacneof
        L->R        == !=
        L->R        &
        L->R        ^
        L->R        |
        L->R        &&
        L->R        ||
        R->L        ? :
        R->L        = *= /= %=
                    += -= <<= >>=
                    >>>= &= ^= |=

2）只有单目运算符，三元运算符和赋值运算符时从右边向左边运算的
1.算术运算符

package com.yl.pdfdemo.day01;

/**
 * @Author wfj
 * @Date 2021/1/10
 * @Description 算数运算符
 * @Version 1.0
 */

public class AriTest {

    public static void main(String[] args) {
        /**
         * 运算符之一：算术运算符
         * + - * / % 前++ 后++ 前-- 前-- 后--
         *
         */
        int num1 = 12;
        int num2 = 5;
        int result = num1/num2;
        System.out.println(result);//结果为2

        int result2 = num1 / num2 * num2;
        System.out.println(result2);//结果为10
        double result3 = num1 / num2 + 0.0;//2.0
        double result4 = num1 / (num2 + 0.0);//2.4
        double result5 = (double)num1 / num2;//2.4
        double result6 = (double)(num1 / num2);//2.0
        System.out.println(result5);
        System.out.println(result6);

        // % 取余
        //结果的符号与被模数的符号一样
        int m1 = 12;
        int n1 = 5;
        System.out.println("m1%n1=:" + m1 % n1);//2

        int m2 = -12;
        int n2 = 5;
        System.out.println("m2%n2=:" + m2 % n2);//-2

        int m3 = 12;
        int n3 = -5;
        System.out.println("m3%n3=:" + m3 % n3);//2

        int m4 = -12;
        int n4 = -5;
        System.out.println("m4%n4=:" + m4 % n4);//-2

        //**********************************************
        //前++ 先自增1，再运算
        //后++ 先运算，再自增1
        int a1 = 10;
        int b1 = ++a1;
        System.out.println("a1=" + a1 + "," + "b1=" + b1);//a1 11 b1 11

        int a2 = 10;
        int b2 = a2++;
        System.out.println("a2=" + a2 + "," + "b2=" + b2);//a2 11 b2 10

        //注意点：
        short s1 = 10;
        //编译失败
        //s1 = s1 + 1;
        //s1 = (short)(s1 + 1);//正确的
        s1++;//自增1不会改变本身变量的数据类型
        System.out.println(s1);

        //问题
        byte b = 127;
        b++;
        System.out.println(b);//-128
        b++;
        System.out.println(b);//127

        // 前-- 先减1，再运算
        // 后-- 先运算，再减1
        int a3 = 10;
        int b3 = --a3;
        System.out.println("a3=" + a3 +"+" + "a3=" + b3);//a3 9 b3 9

        int a4 = 10;
        int b4 = a4--;
        System.out.println("a4=" + a4 +"+" + "a4=" + b4);//a4 9 b4 10

        //打印百十个上的数
        //357
        int num = 357;
        int bai = num / 100;
        int shi = num % 100 /10;
        int ge = num % 10;
        System.out.println("百位数为："+bai);
        System.out.println("百位数为："+shi);
        System.out.println("百位数为："+ge);

    }
}

2.赋值运算符

package com.yl.pdfdemo.day01;

/**
 * @Author wfj
 * @Date 2021/1/10
 * @Description 运算符
 * @Version 1.0
 */

public class AirTest2 {

    public static void main(String[] args) {
        /**
         * 符号=
         * 当=两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理
         * 支持连续赋值
         * 扩展赋值运算符：+=，-=，*= ，/+，%=
         */
        int i1 = 10;
        int j1 = 10;

        int i2,j2;
        //连续赋值
        i2 = j2 = 10;

        int i3 = 10,j3=20;

        //***********************
        int num1 = 10;
        num1 += 2;//num1 = num1 + 2
        System.out.println(num1);//12

        int num2 = 12;
        num2 %= 5;//num2 = num2 % 5
        System.out.println(num2);//2

        short s1 = 10;
        //s1 = s1 + 1;编译失败
        s1 += 1;//编译通过，通过这种方式，变量的数据类型不会改变
        System.out.println(s1);

        //练习1
        int i = 1;
        i *= 0.1;
        System.out.println(i);//0
        i++;
        System.out.println(i);//1

        //练习2
        int m = 3;
        int n = 2;
        n *= m++;
        System.out.println(m);//4
        System.out.println(n);//6

        //练习3
        int t = 10;
        t += (t++) + (++t);//t = t + (t++) + (++t)
        System.out.println(t);//32
    }
}

3.比较运算符

package com.yl.pdfdemo.day01;

/**
 * @Author wfj
 * @Date 2021/1/10
 * @Description 运算符
 * @Version 1.0
 */

public class AirTest3 {
    public static void main(String[] args) {
        /**
         * 比较运算符
         * ==， >= ，<= ,!=,instanceof
         *
         * 比较运算符的结果是Boolean类型
         *
         */
        int i = 10;
        int j = 20;
        System.out.println(i == j);//true
        System.out.println(i = j);//20

        boolean b1 = true;
        boolean b2 = false;
        System.out.println(b1 == b2);//false
        System.out.println(b2 = b1);//true
    }
}

4.逻辑运算符

package com.yl.pdfdemo.day01;

/**
 * @Author wfj
 * @Date 2021/1/10
 * @Description 运算符
 * @Version 1.0
 */

public class AirTest4 {
    public static void main(String[] args) {
        /**
         * 逻辑运算符
         * &逻辑与，&&短路与，|逻辑或，||短路或，!逻辑非，^逻辑异或
         * a        b           a&b         a&&b        a|b         a||b        !a      !b      a^b
         * true     true        true        true        true        true        false   false   false
         * a        b
         * true     false       false       false       true        true        false   true    true
         * a        b
         * false    true        false       false       true        true        true    false   true
         * a        b
         * false    false       true        true        false       false       true    true    false
         */
        //区分&和&&
        //&两边的条件都会判断
        //&&当第一个条件不符合条件时，后面的条件都不会继续去判断
        boolean b1 = true;
        int num1 = 10;
        b1 = false;
        if (b1 & (num1++ > 0)) {
            System.out.println("java");
        } else {
            System.out.println("vue");
        }
        System.out.println(num1);//11

        boolean b2 = true;
        int num2 = 10;
        b2 = false;
        if (b2 && (num2++ > 0)) {
            System.out.println("java");
        } else {
            System.out.println("vue");
        }
        System.out.println(num2);//10

        //区分|和||
        //和上面&，&&一样，|会判断所有的条件
        //当第一个条件为false时，|和||都会继续去判断其他条件
        //当第一个条件为true时，|会判断所有的条件，而||不会
        int num3 = 10;
        boolean b3 = false;
        b3 = true;
        if (b3 | (num3++ > 0)) {
            System.out.println("java");
        } else {
            System.out.println("vue");
        }
        System.out.println(num3);//11

        int num4 = 10;
        boolean b4 = false;
        b4 = true;
        if (b4 || (num4++ > 0)) {
            System.out.println("java");
        } else {
            System.out.println("vue");
        }
        System.out.println(num4);//10

    }
}

5.位运算，位运算是直接对整数的二进制进行的运算

package com.yl.pdfdemo.day01;

/**
 * @Author wfj
 * @Date 2021/1/10
 * @Description 运算符
 * @Version 1.0
 */

public class AirTest5 {
    public static void main(String[] args) {
        /**
         * 老题：如何高效计算2*8
         * 2<<3或者8<<1
         *
         * 位运算符，注意：没有<<<
         * << 左移，空位补0，被移除的最高位移除
         *  在一定范围内，每先左移动一位，就相当于*2
         *
         * >> 右移，被移动的二进制最高位是0，右移后，空缺位补0，被移动的二进制最高位位1，右移后，空缺位补1
         *  在一定范围内，每右移一位，就相当于/2
         *
         * >>> 无符号右移，被移动的二进制最高位无论是0还是1，空缺位都补0
         *
         *  & 与运算，只有1&1时结果才为1，否则为0
         *
         *  | 或运算，只有0|0时结果为0，否则为1
         *
         *  ^ 异或运算，相同二进制位进行位运算时，结果为0，不同二进制位进行位运算时，结果才为1
         *  1^1=0,0^0=0,1^0=1
         *
         *  ~ 取反运算,对于正数而言，各二进制码按照补码按位取反，对于负数而言，各二进制按照补码进行按位取反
         *
         */
        int i = 21;
        System.out.println(i<<2);//84,相当于21*2的2次方
        System.out.println(i<<3);//168,相当于21*2的3次方

        int m = 12;
        int n = 5;
        System.out.println(m&n);//4
        System.out.println(m|n);//13
        System.out.println(m^n);//9

        //练习：交换两个变量的值
        int num1 = 10;
        int num2 = 20;
        System.out.println(num1);
        System.out.println(num2);
        //方法一：定义临时变量
//        int temp;
//        temp = num1;
//        num1 = num2;
//        num2 = temp;
//        System.out.println(num1);
//        System.out.println(num2);

        //方法二：好处：不用定义临时变量，弊端：相加操作可能超出存储范围，有局限性：只适用于数值类型
//        num1 = num1 + num2;
//        num2 = num1-num2;
//        num1 = num1 - num2;
//        System.out.println(num1);
//        System.out.println(num2);

        //方法三：使用位运算符
        //公式k = (m^n) 那么n = k ^ m = （m ^ n） ^ m
        num1 = num1 ^ num2;
        num2 = num1 ^ num2;
        num1 = num1 ^ num2;
        System.out.println(num1);//20
        System.out.println(num2);//10
    }
}

6.三元运算符

package com.yl.pdfdemo.day01;

/**
 * @Author wfj
 * @Date 2021/1/10
 * @Description 运算符
 * @Version 1.0
 */

public class AirTest6 {
    public static void main(String[] args) {
        /**
         * 三元运算符
         *
         * 凡是可以用三元运算符的，都可以用if else来代替
         * 反之则不成立
         * 结构
         * （条件表达式）? 表达式1 : 表达式2
         * 说明
         *  根据条件表达式来判断，如果为true，执行表达式1，否则执行表达式2
         *
         */

        //获取两个数的较大值
        int m = 10;
        int n = 20;
        int max = (m>n) ? m : n;
        System.out.println(max);

        double dmax = (m > n) ? 1 : 2.0;
        System.out.println(dmax);

        //**********************************
        n = 12;
        String maxStr = (m > n) ? "m大于n" : ((m==n) ? "m等于n" : "m小于n");
        System.out.println(maxStr);

        // 获取三个数最大的一个
        int a = 10;
        int b = 20;
        int c = -20;
        int max1 = (a > b) ? a : b;
        int max2 = (max1 > c) ? max1 : c;
        System.out.println(max2);

        int max3 = ((a > b) ? a : b) > c ? ((a > b) ? a : b) : c;
        System.out.println(max3);
    }
}