【Java】——运算符详解

个人主页：User_芊芊君子

🎉欢迎大家点赞👍评论📝收藏⭐文章

文章目录

• 1.什么是运算符
• 2.算术运算符
• • • 1.1基本四则运算符：加减乘除模(+ - * / %)
    • 1.2增量运算符 += -= *= %=
    • 1.3⾃增/⾃减运算符 ++ --
• 3.关系运算符
• 4.`逻辑运算符`
• • • 4.1逻辑与 &&
    • 4.2逻辑||（与&&相反）
    • 4.3 逻辑非！
    • 4.4短路求值
• 5.位运算符
• • • 5.1按位与&
    • 5.2按位或|
    • 5.3按位取反~
    • 5.4 按位异或 ^
• 6.移位运算符
• • • 6.1左移<<
    • 6.2右移>>
    • 6.3无符号右移>>>
• 7.条件运算符

1.什么是运算符

运算符是操作数据的基本工具，就像数学中的加减除运算符号，Java提供了丰富的运算符类型，可分为以下几类：

• 算术运算符：+，-，*，/，%，++，--
• 赋值运算符：=，+=，-=，*=，/=，%=
• 关系运算符：>,<,==,>+,<=,!=
• 逻辑运算符：&&，||，！，^
• 位运算符：&，|,~,^,<<,>>,>>>
• 三元运算符：？，：

2.算术运算符

1.1基本四则运算符：加减乘除模(+ - * / %)

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 5;
        System.out.println(a+b);//15
        System.out.println(a-b);//5
        System.out.println(a*b);//50
        System.out.println(a%b);//0
        System.out.println(a/b);//2
    }
}

• int / int 结果还是int类型，而且会向下取整，eg:

public class Test {
    public static void main(String[] args) {
        int a = 3;
        int b = 2;
        System.out.println(a/b);//1--在Java中，会向下取整，即小数点后全舍掉
        double d = a*1.0/b;
        System.out.println(d);//1.5--这样计算可以得到数学中计算的结果
    }
}

• 做除法时，右操作数不能为0

public class Test {
    public static void main(String[] args) {
        int a = 1;
        int b = 0;
        System.out.println(a/b);
    }
}

• 两侧操作数类型不⼀致时，向类型⼤的提升

public class Test {
    public static void main(String[] args) {
        System.out.println(1+0.1);//1.1，+的左侧是int，右侧是double，在加之前int被提升为double
    }

1.2增量运算符 += -= *= %=

public class Test {
    public static void main(String[] args) {
        int a = 1;
        a += 2;
        System.out.println(a);
        a -= 2;
        System.out.println(a);
        a *= 2;
        System.out.println(a);
        a %= 2;//取余
        System.out.println(a);
    }
}

• 增量运算符在计算的时候，可以不进⾏强制类型转换

public class Test {
    public static void main(String[] args) {
        double a = 1.1;
        int b = 1;
        b += a;//不会报错
        //b = b + a;此时会编译报错，等号右边被提升为了double类型
    }
}

1.3⾃增/⾃减运算符 ++ --

这里与C语言一样，刚开始学习的小白会遇到一些问题，大家可以去看看博主之前写的C语言系列
C语言中的操作符概括

public class Test {
    public static void main(String[] args) {
        int a = 1;
        a++;// 后置++  表⽰给a的值加1，此时a的值为2
        System.out.println(a++);// 注意：后置++  是先使⽤变量原来值，表⽰式结束时给变量+1，因此输出2
        System.out.println(a);// 输出3
        ++a;// 前置++ 表⽰给a的值加1
        System.out.println(++a);// 注意：前置++是先给变量+1，然后使⽤变量中的值，因此输出5
        System.out.println(a);//输出5
    }
}

注意：
• 如果单独使⽤，【前置++】和【后置++】没有任何区别
• 如果混合使⽤，【前置++】先+1，然后使⽤变量+1之后的值，【后置++】先使⽤变量原来的值，表达式结束时给变量+1

• 只有变量才能使⽤⾃增/⾃减运算符，常量不能使⽤，因为常量不允许被修改

3.关系运算符

关系运算符主要有六个:== != < > <= >= ，其计算结果是 true 或者false 。

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println(a == b);//false
        System.out.println(a != b);//true
        System.out.println(a < b);//true
        System.out.println(a > b);//false
        System.out.println(a <= b);//true
        System.out.println(a >= b);//false
    }
}

注意：当需要多次判断时，不能连着写，⽐如：3 < a < 5，Java程序与数学中是有区别的

4.逻辑运算符

逻辑运算符主要有三个: && || ! ，运算结果都是 boolean类型。

4.1逻辑与 &&

1. 语法规则：表达式1 && 表达式2，左右表达式必须是boolean类型的结果。
2. 相当于现实⽣活中的且，⽐如：如果是学⽣，并且 带有学⽣证 才可以享受半票。
3. 两个表达式都为真，结果才是真，只要有⼀个是假，结果就是假。

public class Test {
    public static void main(String[] args) {
        int a = 1 ;
        int b = 2 ;
        System.out.println(a == 1 && b == 2);//左为真 且 右为真 则结果为真
        System.out.println(a == 1 && b > 100);// 左为真 但 右为假 则结果为假
        System.out.println(a >10 && b == 2);// 左为假 但 右为真 则结果为假
        System.out.println(a >10 && b > 10);// 左为假 且 右为假 则结果为假
    }
}

4.2逻辑||（与&&相反）

语法规则：表达式1 || 表达式2，左右表达式必须是boolean类型的结果

public class Test {
    public static void main(String[] args) {
        int a = 1;
        int b = 2;
        System.out.println(a == 1 || b == 2);// 左为真 且 右为真 则结果为真
        System.out.println(a == 1 || b > 10);// 左为真 但 右为假 则结果也为真
        System.out.println(a > 10 || b == 2);// 左为假 但 右为真 则结果也为真
        System.out.println(a > 10 || b > 10);// 左为假 且 右为假 则结果为假
    }
}

4.3 逻辑非！

语法规则：! 表达式
真变假，假变真。

4.4短路求值

&& 和 || 遵守短路求值的规则.

public class Test {
    public static void main(String[] args) {
        System.out.println(10 > 20 && 10 / 0 == 0);//打印false
        System.out.println(10 < 21 || 10 / 0 == 0);//打印true
    }
}

我们都知道, 计算 10 / 0 会导致程序抛出异常. 但是上⾯的代码却能正常运⾏, 说明 10 / 0 并没有真正被求值.
注意:

• 对于 && , 如果左侧表达式值为 false, 则表达式结果⼀定是 false, ⽆需计算右侧表达式.

• 对于||, 如果左侧表达式值为 true, 则表达式结果⼀定是 true, ⽆需计算右侧表达式.

• & 和 | 如果表达式结果为 boolean 时, 也表⽰逻辑运算. 但与 && || 相⽐, 它们不⽀持短路求值.

5.位运算符

Java 中数据存储的最⼩单位是字节，⽽数据操作的最⼩单位是⽐特位. 字节是最⼩的存储单位，每个字节是由8个⼆进制⽐特位组成的，多个字节组合在⼀起可以表⽰各种不同的数据。

位运算符主要有四个:& | ~ ^，除 ~是⼀元运算符外，其余都是⼆元运算符。 位操作表⽰按⼆进制位运算. 计算机中都是使⽤⼆进制来表⽰数据的(01构成的序列), 按位运算就是在按照⼆进制位的每⼀位依次进⾏计算.

5.1按位与&

如果两个二进制位都是1，则结果为1，否则为0
进⾏按位运算, 需要先把 10 和 20 转成⼆进制, 分别为 1010 和 10100

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println(a & b);
    }
}

5.2按位或|

如果两个⼆进制位都是 0, 则结果为 0, 否则结果为 1.

注意: 当 & 和 | 的操作数为整数(int, short, long, byte) 的时候, 表⽰按位运算, 当操作数为 boolean 的时候, 表⽰逻辑运算.

5.3按位取反~

如果该位为 0 则转为 1, 如果该位为 1 则转为 0

public class Test {
    public static void main(String[] args) {
        int a = 0xf;
        System.out.printf("%x\n", ~a);
    }
}

注意:

• 0x 前缀的数字为⼗六进制数字. ⼗六进制可以看成是⼆进制的简化表⽰⽅式. ⼀个⼗六进制数字对应 4 个⼆进制位.

• 0xf 表⽰ 10 进制的 15, 也就是⼆进制的 1111 • printf 能够格式化输出内容, %x 表⽰按照⼗六进制输出.

5.4 按位异或 ^

如果两个数字的⼆进制位相同, 则结果为 0, 相异则结果为 1

6.移位运算符

移位运算符有三个: << >> >>>，都是⼆元运算符，且都是按照⼆进制⽐特位来运算的。

6.1左移<<

最左侧位不要了, 最右侧补 0.

//  0000 1011
//<<0001 0110

6.2右移>>

最右侧位不要了, 最左侧补符号位(正数补0, 负数补1)

//  0000 1011
//>>0000 0101

6.3无符号右移>>>

注意:

1. 左移 1 位, 相当于原数字 * 2. 左移 N 位, 相当于原数字 * 2 的N次⽅. 【针对正数⽽⾔】
2. 右移 1 位, 相当于原数字 / 2. 右移 N 位, 相当于原数字 / 2 的N次⽅. 【针对正数⽽⾔】
3. 由于计算机计算移位效率⾼于计算乘除, 当某个代码正好乘除 2 的N次⽅的时候可以⽤移位运算代 替. 【针对正数⽽⾔】
4. 移动负数位或者移位位数过⼤都没有意义.

7.条件运算符

表达式1 ? 表达式2 : 表达式3

• 当表达式1 的值为 true 时, 整个表达式的值为 表达式2的值;
• 当 表达式1 的值为 false 时, 整个表达式的值为表达式3 的值. 也是 Java 中唯⼀的⼀个 三⽬运算符, 是条件判断语句的简化写法.

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = a>b ? 1:2;//如果a>b返回1，否则返回2
        System.out.println(c);
    }
}

表达式2和表达式3的结果要是同类型的，除⾮能发⽣类型隐式类型转换