【Java学习笔记】运算符

运算符

运算符的类型

算数运算符

赋值运算符

关系运算符（比较哦啊运算符）

逻辑运算符

三元运算符

位运算符（需要二进制基础）

---

一、算数运算符

运算符	计算	范例	结果
+	正号	+7	7
-	负号	b=11; -b	-11
+	加法	9+9	18
-	减法	10-8	2
*	乘法	7*8	56
/	除法	9/9	1
%	取模(取余)	11%9	2
++	自增（前）	a=2;b=b++;a	a=3; b=2
++	自增（后）	a=2;b=++a;	a=3; b=3
--	自减（前）	a=2;b=b--;a	a=2; b=1
--	自减（后）	a=2;b=--a;	a=1; b=1
++	字符串相加	"hsp"+"edu"	"hspedu"

注意点

a++：先用后加

++a：先加后用

/：除法的结果取决于左右操作数，如果都是整数，结果就是整数，例如：8/5=1

%：取模的本质是a % b = a - a / b * b

注意：如果a是负数，公式为a % b = a - (int)a / b * b，得到的结果是近似值

案例说明

public class hello{
    public static void main(String[] args){

        //在%的本质看一个公式!!!!a%b=a-a/b*b
        //-10%3=>-10-(-10)/3*3=-10+9=-1
        //10%-3=10-10/(-3)*(-3)=10-9=1
        //-10%-3= (-10)-(-10)/(-3)*(-3)=-10+9=-1

        System.out.println(10 % 3); //1
        System.out.println(-10 % 3); //-1
        System.out.println(10 %-3); //1
        System.out.println(-10 %-3);//-1
    }
}

自增运算符的底层本质

### 自增的值会采用一个临时变量保存，后续再重新赋值

### 面试题一

int i = 1;
i = ++i; // 规则使用临时变量: (1) i = i + 1; (2) temp = i; (3) i = temp;
System.out.println(i); // 2

### 面试题二

int i = 1; // i -> 1
i = i++; // 规则使用临时变量: (1) temp = i; (2) i = i + 1; (3) i = temp;
System.out.println(i); // 1

---

二、赋值运算符

注意是从右往左运算，把某个值赋给变量

类型

= : 赋值运算符，将右边的值赋给左边的变量

+= : 加法赋值运算符，将右边的值加到左边的变量上

-= : 减法赋值运算符，将右边的值从左边的变量中减去

*= : 乘法赋值运算符，将右边的值与左边的变量相乘

/= : 除法赋值运算符，将左边的变量除以右边的值

%= : 取余赋值运算符，将左边的变量对右边的值取余并赋值

注意：符合赋值运算符会进行类型转换

byte b = 2 ; b += 3 ; b++

底层实际是 b =(byte)(b+3)

如果写成 b=b+3 必然报错，int 类型不可以赋值给 byte 类型

---

三、关系运算符

关系运算符的结果都是 boolean 型，也就是要么是 true，要么是 false

运算符	计算	范例	结果
==	相等于	8 == 7	false
!=	不等于	8 != 7	true
<	小于	8 < 7	false
>	大于	8 > 7	true
<=	小于等于	8 <= 7	false
>=	大于等于	8 >= 7	true
instanceof	检查是否是类的对象	"hsp" instanceof String	true

---

四、逻辑运算符

类型

逻辑与

### a `&` b

### a `&&` b

逻辑或

### a `|` b

### a `||` b

!a：逻辑非

a ^ b：逻辑异或

使用规则

a & b: 逻辑与：当 a 和 b 同时为 true，则结果为 true，否则为 false

a && b: 逻辑与：&& 短路运算：当 a 和 b 同时为 true，则结果为 true，否则为 false

a | b: 逻辑或：当 a 和 b, 有一个为 true，则结果为 true，否则为 false

a || b: 逻辑或：|| 短路运算：当 a 和 b, 有一个为 true，则结果为 true，否则为 false

!a: 取反：或者非运算。当 a 为 true，则结果为 false，当 a 为 false，则结果为 true

a ^ b: 逻辑异或：当 a 和 b 不同时，则结果为 true，否则为 false

区别|| 和 | ; && 和 &

&& 短路与：如果第一个条件为 false，则第二个条件不会判断，最终结果为 false，效率高。

& 逻辑与：不管第一个条件是否为 false，第二个条件都要判断，效率低。

|| 短路或：如果第一个条件为 true，则第二个条件不会判断，最终结果为 true，效率高。

| 逻辑或：不管第一个条件是否为 true，第二个条件都要判断，效率低。

总结

短路在条件成立时不会继续判断后面的条件

逻辑非，逻辑与在条件成立时会继续判断后面的条件

& 和 && 的代码示例

public class Hello {

    // 编写一个main方法
    public static void main(String[] args) {

        // && 短路与和 & 案例演示
        int age = 50;

        // 使用 && 短路与
        if (age > 20 && age < 90) {
            System.out.println("ok100");
        }

        // 使用 & 逻辑与
        if (age > 20 & age < 90) {
            System.out.println("ok200");
        }

        // 区别
        int a = 4;
        int b = 9;

        // 对于 && 短路与而言，如果第一个条件为 false, 后面的条件不再判断
        // 对于 & 逻辑与而言，如果第一个条件为 false, 后面的条件仍然会判断
        if (a < 1 & ++b < 50) {
            System.out.println("ok300");
        }

        System.out.println("a=" + a + " b=" + b); // 输出 a=4 b=10
    }
}

| 和 ||的代码示例

public class LogicOperator02 {
    // 编写一个main方法
    public static void main(String[] args) {
        // || 短路或和 | 逻辑或案例演示
        // || 规则: 两个条件中只要有一个成立，结果为 true，否则为 false
        // | 规则: 两个条件中只要有一个成立，结果为 true，否则为 false
        int age = 50;

        // 使用 || 短路或
        if (age > 20 || age < 30) {
            System.out.println("ok100");
        }

        // 使用 | 逻辑或
        if (age > 20 | age < 30) {
            System.out.println("ok200");
        }

        // 看看区别
        // (1) || 短路或：如果第一个条件为 true，则第二个条件不会判断，最终结果为 true，效率高
        // (2) | 逻辑或：不管第一个条件是否为 true，第二个条件都要判断，效率低

        int a = 4;
        int b = 9;

        // 使用 || 短路或，如果条件满足，第一个条件为 true
        if (a > 1 || ++b > 4) { // 可以换成 | 来测试
            System.out.println("ok300");
        }

        // 输出 a 和 b 的值
        System.out.println("a=" + a + " b=" + b); // 4 10
    }
}

五、三元运算符

使用方法示例：int res=a > b ? a++ : --b;

解释：如果条件成立，执行结果 a，如果条件不成立，执行结果 b

本质是 if - else 结构

代码示例

if(a > b)
{
    res = a;
}
else
{
    res = b;
}

注意：数据类型转换问题

代码示例

public class TernaryOperatorDetail {
    // 编写一个main方法
    public static void main(String[] args) {
        // 表达式1和表达式2要为可以赋给接收变量的类型
        // (或可以自动转换/或者强制转换)

        int a = 3;
        int b = 8;

        // 使用三元运算符进行赋值
        int c = a > b ? (int) 1.1 : (int) 3.4; // 强制转换成 int 类型
        System.out.println("c = " + c); // 输出 c 的值

        double d = a > b ? a : b + 3; // 可以的，满足 int -> double 自动类型转换
        System.out.println("d = " + d); // 输出 d 的值
    }
}

---

运算符优先级示例

. , () []: 数组、方法、成员访问

++ --: 自增、自减

!: 逻辑非（数据类型）

* / %: 乘法、除法、取余

+ -: 加法、减法

<< >>: 位移运算

< <= > >=: 比较运算、instanceof

== !=: 相等、不等于

&: 按位与

^: 按位异或

&&: 逻辑与

||: 逻辑或

? :: 三元运算符

= * = / = % =: 赋值运算符

+= -= <<= >>=: 复合赋值运算符

>>>= &= ^=: 位运算符赋值

说明

从上到下运算符优先级递减

只有单目运算符、赋值运算符是从右向左运算的

不要背，用多了就熟悉了