Java运算符

Java运算符：运算符是一种特殊的符号，用以表示数据的运算，赋值和比较等，具体有以下6种。

1 - 算数运算符

 1 - 取余与自增，自减

// 算数运算符 + - + - * / % (前)++ (后)++ (前)-- (后)-- +(连接运算符)
public class OperatorTest {
    public static void main(String[] args){
        // 1.除号 /
        int num1 = 12;
        int num2 = 5;
        int result1 = num1 / num2;
        System.out.println(result1); // 2
        int result2 = num1 / num2 * num2;
        System.out.println(result2); // 10

        double result3 = num1 / num2;
        System.out.println(result3); // 2.0

        double result4 = num1 / (num2+0.0);
        System.out.println(result4); // 2.4
        double result5 = (double)num1 / num2;
        System.out.println(result5); // // 2.4

        // 2. % 取余运算  开发中经常使用 % 来判断能否被除尽的情况
        int m1 = 12;
        int n1 = 5;
        System.out.println("m1 % n1 = "+m1 % n1); // m1 % n1 = 2
        // 补充：结果的符号与被模数符号相同(如这里 m1 是 -12 的话，结果就是 -2)

        // 3. (前)++ (后)++ (前)-- (后)--
        // (前)++    先自增1，在运算
        // (后)++    先运算，在自增1
        int number1 = 10;
        int b1 = ++number1;
        int number2 = 10;
        int b2 = number2++;
        System.out.println("number1 = " + number1 + "\n"+"b1 = " + b1); // number1=11 b1=11
        System.out.println("number2 = " + number2 + "\n"+"b2 = " + b2); // number2=11 b2=10
        // 注意点：(有一个需求，需要 s1 = 10 变成 s1 = 11)
        short s1 = 10;
        // s1 = s1 + 1; 编译失败
        // s1 = (short)(s1 + 1); 正确写法
        s1++; // 自增1，不会改变本身变量的数据类型
        System.out.println(s1);  // 11

        // 问题
        byte b8 = 127;
        b8++;
        System.out.println(b8); // -128
        // (前)-- (后)--
        // 与 ++ 的使用同理

    }
}

2-练习

// 打印出 189 的 个 十 百 位数的值
public class OperatorTest{
    public static void main(String[] args){
        int num = 189;
        int b = (num / 100) % 10;
        int s = (num / 10) % 10;
        int g = num % 10;
        System.out.println("个位：" + g);
        System.out.println("十位：" + s);
        System.out.println("百位：" + b);
    }
}

2 - 赋值运算符

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

        int num1 = 9;
        num1 += 1;
        System.out.println(num1); // 10

        //注意点:扩展赋值运算时 不会改变本身的数据类型
        short s1 = 10;
        // s1 = s1 + 2; 编译不通过
        s1 += 2;
        System.out.println(s1); // 12
    }
}

补充：开发中希望变量实现+1操作，有几种方法(前提 int num = 10;)

public class StringTest{
    public static void main(String[] args){
        int num = 10;
        // 方法1
        num = num + 1;
        // 方法2
        num += 1;
        // 方法3(推荐)
        num++;
        System.out.println(num); // 13
    }
}

3 - 比较运算符(关系运算符)

注意：比较运算的结果都是boolean型，也就是要么true，要么false，这种运算结果常用在条件判断。

// 比较运算符
// == != < > <= >= instanceof
// 结论：比较运算符的结果都是boolean型  注意:区分 == 和 =
public class OperatorTest{
    public static void main(String[] args){
        int i = 10;
        int j = 20;
        System.out.println(i == j); // false
        System.out.println(j = i); // 10

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

4 - 逻辑运算符

/*
 逻辑运算符
 &-->逻辑与  |-->逻辑或  !-->逻辑非
 &&-->短路与  ||-->短路或  ^-->逻辑异或

 说明：逻辑运算符的操作都是boolean类型的变量
 */
public class OperatorTest{
    public static void main(String[] args){
        // 区分 & 和 &&

        boolean b1 = false;
        int num1 = 10;
        if (b1 & (num1++ > 0)) {
            System.out.println("张飞打野");
        } else {
            System.out.println("韩信打野");
        }
        System.out.println("num1 = "+num1); // num1 = 11
        // &&
        boolean b2 = false;
        int num2 = 10;
        // 短路，没有进行自增
        if (b2 && (num2++ > 0)) {
            System.out.println("张飞打野");
        } else {
            System.out.println("韩信打野");
        }
        System.out.println("num2 = "+num2); // num2 = 10
        /*
        单与 & 和双与 && 的结论：
            相同点1：运算结果都相同
            相同点2：当符号左边是true时，二者都会执行符号右边的运算
            不同点：当符号左边是false是，& 会继续执行符号右边的运算，而 && 不会执行右边符号的运算。
         */

        // 区分 | 和 ||
        // 相同点1：| 和 || 的运算结果都相同
        // 相同点2：当符号左边是false时，二者都会符号右边的运算
        // 不同点：当符号左边是true时，| 会继续执行符号右边的运算，而 || 不会执行符号右边的运算

        // 总结：开发中建议使用 短路 型的，这样不用进行右边的运算，节省内存。

    }
}

// 面试题  程序输出结果？
public class OperatorTest{
    public static void main(String[] args){
        boolean x = true;
        boolean y = false;
        short z = 42;
        if ((z++ == 42) && (y=true)) z++;
        if ((x=false) || (++z == 45)) z++;
        System.out.println("z = "+z); // 46
    }
}

5 - 位运算符(了解)

 

// 位运算符
/*结论：
    1 - 位运算符操作的都是整型数据
    2 - << :在一定范围内，每向左移1位，相当于 * 2
    3 - << :在一定范围内，每向右移1位，相当于 / 2
 */
public class OperatorTest{
    public static void main(String[] args){
        int i = 21;
        System.out.println("i >> 2 :"+(i>>2)); // i >> 2 :5
        System.out.println("i << 2 :"+(i<<2)); // i << 2 :84
    }
}
// 经典面试题：最高效的计算 (2 * 8) ？
class InterviewTest{
    public static void main(String[] args){
        int num = 2;
        int sum = num << 3; // 8 << 1;
        System.out.println("sum = "+sum);
    }
}

6 - 三元运算符

 

/*
 三元运算符
 格式 --> (条件表达式) ? 表达式1 : 表达式2
 说明：
    1-条件表达式的结果为boolean型
    2-根据条件表达式 真或假 决定执行 表达式1 还是 表达式2，如果条件表达式为 true 则执行表达式1，否则执行表达式2.
    3-表达式1 和 表达式 2 要求一致
    4-嵌套使用
 */
public class OperatorTest{
    public static void main(String[] args){
        // 获取两个整数的较大值
        int m = 12;
        int n = 5;
        int max = (m > n) ? m : n;
        System.out.println("较大值为"+max);

        n = 12;
        String maxStr = (m > n) ? "m大" : ((m == n) ? "m和n相等" : "n大");
        System.out.println(maxStr);

        // 获取三个数的最大值
        int x = 10,y = 2,z = 30;
        int max1 = (x > y) ? x : y;
        int max2 = (max1 > z) ? max1 : z;
        System.out.println("max_number="+max2);
    }
}

7 - 运算符的优先级(了解)