【Java基础】7.算数运算符、关系运算符、位运算符、逻辑运算符、赋值运算符、三元运算符

---

前言

Java 语言中，可以把运算符分成以下几组：

• 算术运算符
• 关系运算符
• 位运算符
• 逻辑运算符
• 赋值运算符
• 其他运算符

一、算数运算符

算术运算符用在数学表达式中，它们的作用和在数学中的作用一样。
算数运算符：+ 加、- 减、* 乘、/ 除、% 取余、++ 自增、-- 自减。

%取余：Java中，两个整数相除还是整数，并且是向下取整。
++ 自增、-- 自减分为前置自增自减（++a,–a）和后置自增自减（a++,a–）。
前置自增自减（++a,–a）：先进行自增或者自减运算，再进行表达式运算。即先运算再用。
后置自增自减（a++,a–）：先进行表达式运算，再进行自增或者自减运算。即先用在运算。

public class OperatorDemo1 {
    public static void main(String[] args) {
        // 算数运算符：+ 加、- 减、* 乘、/ 除、% 取余、++ 自增、-- 自减
        int a = 10;
        int b = 3;
        int c = 4;
        int d = 5;
        // + 加
        System.out.println("a + b = " + (a + b)); // a + b = 13
        // - 减
        System.out.println("a - b = " + (a - b)); // a - b = 7
        // * 乘
        System.out.println("a * b = " + (a * b)); // a * b = 30
        // / 除（Java中，两个整数相除还是整数，向下取整）
        System.out.println("b / c = " + (b / c)); // b / c = 0 (0.75 ==> 0)
        // % 取余
        System.out.println("a % b = " + (a % b)); // a % b = 1
        System.out.println("---后缀自增自减法(a++,a--)---");
        // a++ 后置自增,a-- 后置自减。先进行表达式运算，再进行自增或者自减运算。即先用在运算。
        System.out.println("a = " + a); // a = 10
        System.out.println("a++ = " + (a++)); // a++ = 10
        System.out.println("a = " + a); // a = 11
        System.out.println("b = " + b); // b = 3
        System.out.println("b-- = " + (b--)); // b-- = 3
        System.out.println("b = " + b); // b = 2
        System.out.println("---前缀自增自减法(++a,--a)---");
        // ++a 前置自增,--a 前置自减。先进行自增或者自减运算，再进行表达式运算。即先运算再用。
        System.out.println("c = " + c); // c = 4
        System.out.println("++c = " + (++c)); // ++c = 5
        System.out.println("c = " + c); // c = 5
        System.out.println("d = " + d); // d = 5
        System.out.println("--d = " + (--d)); // --d = 4
        System.out.println("d = " + d); // d = 4
    }
}

二、关系运算符

下表为Java支持的关系运算符。

public class OperatorDemo6 {
    public static void main(String[] args) {
        int a = 10;
        int b = 10;
        // ==
        boolean rs = a == b;
        System.out.println("a == b = " + rs); // a == b = true
        // ==
        System.out.println("a == b = " + (a == b)); // a == b = true
        // !=
        System.out.println("a != b = " + (a != b)); // a != b = false
        // >
        System.out.println("a > b = " + (a > b)); //  a > b = false
        // >=
        System.out.println("a >= b = " + (a >= b)); // a >= b = true
        // <
        System.out.println("a < b = " + (a < b)); // a < b = false
        // <=
        System.out.println("a <= b = " + (a <= b)); // a <= b = true

        int i = 10;
        int j = 5;
        System.out.println("i == j = " + (i == j)); // i == j = false
        System.out.println("i != j = " + (i != j)); // i != j = true
        System.out.println("i > j = " + (i > j)); // i > j = true
        System.out.println("i >= j = " + (i >= j)); // i >= j = true
        System.out.println("i < j = " + (i < j)); // i < j = false
        System.out.println("i <= j = " + (i <= j)); // i <= j = false
    }
}

三、位运算符

Java定义了位运算符，应用于整数类型(int)，长整型(long)，短整型(short)，字符型(char)，和字节型(byte)等类型。
位运算符作用在所有的位上，并且按位运算。假设a = 60，b = 13;它们的二进制格式表示将如下：

A = 0011 1100
B = 0000 1101
-----------------
A&B = 0000 1100
A | B = 0011 1101
A ^ B = 0011 0001
~A= 1100 0011

下表列出了位运算符的基本运算，假设整数变量 A 的值为 60 和变量 B 的值为 13：

public class OperatorDemo2 {
    public static void main(String[] args) {
        int a = 60; // 60 = 0011 1100
        int b = 13; // 13 = 0000 1101
        int c = 0;
        c = a & b; // 12 = 0000 1100
        System.out.println("a & b = " + c); // a & b = 12

        c = a | b; // 61 = 0011 1101
        System.out.println("a | b = " + c); // a | b = 61

        c = a ^ b; // 49 = 0011 0001
        System.out.println("a ^ b = " + c); // a ^ b = 49

        c = ~a; // -61 = 1100 0011
        System.out.println("~a = " + c); // ~a = -61

        c = a << 2; // 240 = 1111 0000
        System.out.println("a << 2 = " + c); // a << 2 = 240

        c = a >> 2; // 15 = 1111
        System.out.println("a >> 2  = " + c); // a >> 2  = 15

        c = a >>> 2; // 15 = 0000 1111
        System.out.println("a >>> 2 = " + c); // a >>> 2 = 15
    }
}

四、逻辑运算符

下表列出了逻辑运算符的基本运算，假设布尔变量A为真，变量B为假。

public class OperatorDemo7 {
    public static void main(String[] args) {
        double d = 9.8;
        int i = 7;
        System.out.println("d >= 6.95 ：" + (d >= 6.95)); // d >= 6.95 ：true
        System.out.println("i >= 8 : " + (i >= 8)); // i >= 8 : false

        // 1.& 逻辑与
        // 注意：必须前后都是true,结果才是true
        System.out.println("& 逻辑与 : " + (d >= 6.95 & i >= 8)); // & 逻辑与 : false

        // 2.| 逻辑或
        // 注意：只要有一个是true,结果就一定是true
        System.out.println("| 逻辑或 : " + (d >= 6.95 | i >= 8)); // | 逻辑或 : true

        // 3.！ 逻辑非
        System.out.println("!true : " + !true); // !true : false
        System.out.println("!false : " + !false); // !false : true

        // 4.逻辑异或：必须两个不同结果才是true
        System.out.println("false ^ true : " + (false ^ true)); // false ^ true : true
        System.out.println("true ^ false : " + (true ^ false)); // true ^ false : true
        System.out.println("true ^ true : " + (true ^ true)); // true ^ true : false
        System.out.println("false ^ false : " + (false ^ false)); // false ^ false : false

        System.out.println("----&&、&、||、|的区别----");
        int a = 10;
        int b = 20;
        System.out.println("----&& 短路与,左边false,右边不执行----");
        System.out.println("变量b : " + b); // 变量b : 20
        System.out.println(a > 100 && ++b > 10); // false
        System.out.println("变量b : " + b); // 变量b : 20

        int x = 10;
        int y = 20;
        System.out.println("----& 逻辑与,两边都执行----");
        System.out.println("变量y : " + y); // 变量y : 20
        System.out.println(x > 100 & ++y > 10); // false
        System.out.println("变量y : " + y); // 变量y : 21

        int k = 10;
        int l = 20;
        System.out.println("----|| 短路或,左边true,右边不执行----");
        System.out.println("变量l : " + l); // 变量l : 20
        System.out.println(k > 2 || ++l > 10); // true
        System.out.println("变量l : " + l); // 变量l : 20

        int o = 10;
        int p = 20;
        System.out.println("----| 逻辑或,两边都执行----");
        System.out.println("变量p : " + p); // 变量p : 20
        System.out.println(o > 2 | ++p > 10); // true
        System.out.println("变量p : " + p); // 变量p : 21
    }
}

五、赋值运算符

下面是Java语言支持的赋值运算符：

public class OperatorDemo5 {
    public static void main(String[] args) {
        // = 基本赋值运算符
        // += 加后赋值
        // -= 减后赋值
        // *= 乘后赋值
        // /= 除后赋值
        // %= 取余后赋值

        int a = 10;
        int b = 20;
        int c = 0;
        // = 基本赋值运算符,把a的值给c,c = 20
        c = b;
        System.out.println("c = b = " + c); // c = b = 20
        // += 加后赋值,把c + a后的值给c，c = 20 + 10
        c += a;
        System.out.println("c += a  = " + c); // c += a  = 30
        // -= 减后赋值,把c - a后的值给c，c = 30 - 10
        c -= a;
        System.out.println("c -= a = " + c); // c -= a = 20
        // *= 乘后赋值,把c * a后的值给c，c = 20 * 10
        c *= a;
        System.out.println("c *= a = " + c); // c *= a = 200
        // /= 除后赋值,把c / a后的值给c,c = 200 / 10
        c /= a;
        System.out.println("c /= a = " + c); // c /= a = 20
        int d = 15;
        // %= 取余后赋值,把d/a取余后的值给d
        d %= a;
        System.out.println("d %= a  = " + d); // d %= a  = 5

        System.out.println("----位运算符+赋值运算符----");
        System.out.println("现在变量c的值 = " + c);
        c <<= 2;
        System.out.println("c <<= 2 = " + c); // c <<= 2 = 80
        c >>= 2;
        System.out.println("c >>= 2 = " + c); // c >>= 2 = 20
        c >>= 2;
        System.out.println("c >>= 2 = " + c); // c >>= 2 = 5
        c &= a;
        System.out.println("c &= a  = " + c); // c &= a  = 0
        c ^= a;
        System.out.println("c ^= a   = " + c); // c ^= a   = 10
        c |= a;
        System.out.println("c |= a   = " + c); // c |= a   = 10
    }
}

六、其他运算符

1.三元运算符

条件运算符也被称为三元运算符。该运算符有3个操作数，并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。
格式：条件表达式 ？ 值1 ： 值2，true为值1，false为值2。

public class OperatorDemo8 {
    public static void main(String[] args) {
        // 格式： 条件表达式 ？ 值1 ： 值2
        // variable x = (expression) ? value if true : value if false
        // true为值1，false为值2
        double score = 18;
        // 表达式score >= 60，是false，所以是值2，返回结果是String类型的rs
        String rs = score >= 60 ? "考试通过" : "挂科";
        System.out.println("rs = " + rs); // rs = 挂科

        System.out.println("----例子1：需要从2个整数中找出较大值----");
        int a = 10000;
        int b = 2000;
        // 返回结果是int类型的max
        int max = a > b ? a : b;
        System.out.println("max = " + max); // max = 10000

        System.out.println("----例子2：需要从3个整数中找出最大值----");
        int i = 10;
        int j = 30;
        int k = 50;
        // 1、找出2个整数的较大值
        int temp = i > j ? i : j;
        System.out.println("temp = " + temp); // temp = 30
        // 2、拿临时变量与第三个变量的值继续比较
        int rsMax = temp > k ? temp : k;
        System.out.println("rsMax = " + rsMax); // rsMax = 50

        System.out.println("----拓展知识----");
        int rs1 = i > j ? (i > k ? i : k) : (j > i ? j : i);
        int temp1 = i > k ? i : k;
        System.out.println("temp1 = " + temp1); // temp1 = 50
        int temp2 = j > i ? j : i;
        System.out.println("temp2 = " + temp2); // temp2 = 30
        int temp3 = i > j ? 50 : 30;
        System.out.println("temp3 = " + temp3); // temp3 = 30
        System.out.println("rs1 = " + rs1); // rs1 = 30
    }
}

2.instanceof 运算符

该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）。
格式：( Object reference variable ) instanceof (class/interface type)
如果运算符左侧变量所指的对象，是操作符右侧类或接口(class/interface)的一个对象，那么结果为真。

public class Test1 {
    public static void main(String[] args) {
        // instanceof运算符严格来说是Java中的一个双目运算符，用来测试一个对象是否为一个类的实例。
        // 格式：boolean result = obj instanceof Class;

        String name = "James";
        // 由于 name 是 String 类型，所以返回真
        boolean result = name instanceof String;
        System.out.println("变量name是否是String类型：" + result); // 变量name是否是String类型：true

        int a = 10;
        // 报错，因为a是基本数据类型，不是引用类型
        // C = a instanceof Integer;

        Integer b = 1; // 自动装箱
        boolean result2 = b instanceof Integer;
        System.out.println("变量b是否是Integer类型：" + result2); // 变量b是否是Integer类型：true
    }
}

七、运算符优先级

当多个运算符出现在一个表达式中，谁先谁后呢？这就涉及到运算符的优先级别的问题。在一个多运算符的表达式中，运算符优先级不同会导致最后得出的结果差别甚大。