相关运算符的介绍

最新推荐文章于 2024-06-14 15:02:13 发布

‘(尐儍苽-℡

最新推荐文章于 2024-06-14 15:02:13 发布

阅读量516

点赞数 3

分类专栏：初识JavaSE 文章标签： java

本文链接：https://blog.csdn.net/qq_67458830/article/details/128896010

版权

初识JavaSE 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

文章目录

算术运算符
关系运算符
逻辑运算符
位运算符
移位运算符
条件运算符
运算符的优先级

一、算术运算符

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

public class HelloWorld{

    public static void main(String[] args) {
	int a = 20;
	int b = 10;
	System.out.println(a + b); // 30
	System.out.println(a - b); // 10
	System.out.println(a * b); // 200
	System.out.println(a / b); // 2
	System.out.println(a % b); // 0 --->模运算相当于数学中除法的余数
	}
}

编译结果：

public class HelloWorld{

    public static void main(String[] args) {
    	int a = 1;
		int b = 0;
		System.out.println(a / b);
    	System.out.println(11.5 % 2.0);
		System.out.println(1+0.2); // +的左侧是int，右侧是double，在加之前int被提升为double
	}
}

编译结果：

注意： 1、都是二元运算符，使用时必须要有左右两个操作数。int / int 结果还是int类型，而且会向下取整

2、做除法和取模时，右操作数不能为0

3、% 不仅可以对整型取模，也可以对double类型取模，但是没有意义，一般都是对整型取模的

4、两侧操作数类型不一致时，向类型大的提升

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

public class HelloWorld{

    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

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

二、关系运算符

三、逻辑运算符

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

逻辑与 &&

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

表达式 1                                             表达式 2                                                       结果

真                                                         真                                                              真

真                                                         假                                                              假

假                                                         真                                                              假

假                                                         假                                                              假

public class HelloWorld{

    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 > 100 && b == 2); // 左为假 但 右为真 则结果为假
		System.out.println(a > 100 && b > 100); // 左为假 且 右为假 则结果为假
	}
}

逻辑 ||

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

表达式 1                                                表达式 2                                                       结果

真                                                            真                                                               真

真                                                            假                                                               真

假                                                            真                                                               真

假                                                            假                                                               假

public class HelloWorld{

    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 > 100 || b == 2); // 左为假 但 右为真 则结果也为真
		System.out.println(a > 100 || b > 100); // 左为假 且 右为假 则结果为假
	}
}

逻辑非 !

语法规则： ! 表达式

表达式                      结果

真                            假

假                                                                                                  真

public class HelloWorld{

    public static void main(String[] args) {
    	int a = 1;

		System.out.println(!(a == 1)); // a == 1 为true，取个非就是false
		System.out.println(!(a != 1)); // a != 1 为false，取个非就是true
	
}

短路求值

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

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

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

四、位运算符

位运算符主要有四个 : & |~ ^ ，除 ~ 是一元运算符外，其余都是二元运算符。

. 按位与 & : 如果两个二进制位都是 1, 则结果为 1, 否则结果为 0.

public class HelloWorld{

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

按位或 |: 如果两个二进制位都是 0, 则结果为 0, 否则结果为 1.

public class HelloWorld{

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

按位取反 ~: 如果该位为 0 则转为 1, 如果该位为 1 则转为 0

public class HelloWorld{

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

按位异或 ^: 如果两个数字的二进制位相同 , 则结果为 0, 相异则结果为 1

public class HelloWorld{

    public static void main(String[] args) {
		int a = 0x1;
		int b = 0x2;
		System.out.printf("%x\n", a ^ b);//3
	}
}

注意：

当 & 和 | 的操作数为整数(int, short, long, byte) 的时候, 表示按位运算, 当操作数为 boolean 的时候, 表示逻辑运算.
0x 前缀的数字为十六进制数字. 十六进制可以看成是二进制的简化表示方式. 一个十六进制数字对应4个二进制位.
0xf 表示 10 进制的 15, 也就是二进制的 1111
printf 能够格式化输出内容, %x 表示按照十六进制输出.
\n 表示换行符 .
如果两个数相同，则异或的结果为0

五、移位运算符

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

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

public class HelloWorld{

    public static void main(String[] args) {
    	int a = 0x10;
		System.out.printf("%x\n", a << 1);//20
	}
}

右移 >> : 最右侧位不要了 , 最左侧补符号位 ( 正数补 0, 负数补1）。

public class HelloWorld{

    public static void main(String[] args) {
    	int a = 0x10;
		System.out.printf("%x\n", a >> 1);// 运行结果(注意, 是按十六进制打印的)   8
		int b = 0xffff0000;
		System.out.printf("%x\n", b >> 1);// 运行结果(注意, 是按十六进制打印的)	ffff8000
	}
}

无符号右移 >>>: 最右侧位不要了 , 最左侧补 0.

public class HelloWorld{

    public static void main(String[] args) {
    	int a = 0xffffffff;
		System.out.printf("%x\n", a >>> 1);// 运行结果(注意, 是按十六进制打印的)  7fffffff
	}
}