Java运算符有哪些？深入解析Java运算符：从基础到进阶的全方位指南（超全表格）

💻1.前言

在编程中，运算符是处理数据和变量的基本工具。它们不仅使得代码更加简洁，还能极大地提高编程效率。本文还提供了详细的 Java运算符参考表格，涵盖了算术运算符、关系运算符、逻辑运算符、赋值运算符、位运算符、三元运算符以及 instanceof 操作符

instanceof 操作符后面多态中的学习会提及，可以先简单了解

这些运算符是Java 编程中不可或缺的部分，掌握它们能够帮助开发者更加高效地编写代码。

💻2.什么是运算符，什么是表达式？

运算符和表达式在编程中密不可分，二者共同构成了代码中的核心计算逻辑。
表达式是由运算符、变量和常量组成的代码结构，最终可以被计算为一个结果。表达式的核心是运算符，而变量和常量则是被运算符操作的对象。

📌运算符

运算符是对常量或者变量进行操作的符号，简单点说就类似于我们小学学习的+、-、×、÷

🌟运算符分类

算术运算符：用于执行基本的数学运算，如加法、减法、乘法和除法。例如，+ 运算符用于两个值的加法。

关系运算符：用于比较两个值的大小和关系，如等于、不等于、大于和小于。例如，== 运算符用于判断两个值是否相等。

逻辑运算符：用于进行逻辑操作，如与（AND）、或（OR）和非（NOT）。例如，&& 运算符用于逻辑与运算。

赋值运算符：用于将右侧的值赋给左侧的变量，并支持复合操作。比如，+= 运算符用于将右侧的值加到左侧的变量上。

位运算符：用于对整数类型的数据进行按位操作，如按位与、按位或和按位异或。例如，& 运算符用于按位与运算。

三元运算符：一种简洁的条件判断方式，基于条件表达式的真假返回两个值中的一个。例如，?: 运算符用于根据条件选择值。

instanceof运算符：用于判断对象是否为某个特定类的实例。例如，instanceof 运算符可以检查一个对象是否是某个类或接口的实例。

📌表达式

用运算符把常量或者变量连接起来的，符合Java语法的式子就是表达式，比如 1+1 或者 a+b 就是一个表达式

💻运算符一览表

这张表格通过清晰的分类和具体的示例，旨在帮助 Java 程序员快速掌握常用运算符的使用方法。无论你是 Java 编程的新手还是有经验的开发者，这份参考表格都将成为你日常编程的重要工具。

运算符	描述	示例	输出
算术运算符
`+`	加法运算，连接字符串	`int a = 5 + 3;` `String s = "Hello " + "World";`	`a = 8` `s = "Hello World"`
`-`	减法运算	`int b = 10 - 2;`	`b = 8`
`*`	乘法运算	`int c = 4 * 2;`	`c = 8`
`/`	除法运算	`int d = 8 / 2;`	`d = 4`
`%`	取余运算（求模）	`int e = 7 % 3;`	`e = 1`
`++`	自增运算	`int f = 5; f++;`	`f = 6`
`--`	自减运算	`int g = 5; g--;`	`g = 4`
关系运算符
`==`	等于	`boolean h = (5 == 3);`	`h = false`
`!=`	不等于	`boolean i = (5 != 3);`	`i = true`
`>`	大于	`boolean j = (5 > 3);`	`j = true`
`<`	小于	`boolean k = (5 < 3);`	`k = false`
`>=`	大于等于	`boolean l = (5 >= 3);`	`l = true`
`<=`	小于等于	`boolean m = (5 <= 3);`	`m = false`
逻辑运算符
`&&`	短路逻辑与（AND）	`boolean n = (5 > 3 && 5 < 10);`	`n = true`
`\|\|`	短路逻辑或（OR）	`boolean o = (5 < 3 \|\| 5 < 10);`	`o = true`
`!`	逻辑非（NOT）	`boolean p = !(5 > 3);`	`p = false`
赋值运算符
`=`	赋值	`int q = 5;`	`q = 5`
`+=`	加赋值	`int r = 5; r += 3;`	`r = 8`
`-=`	减赋值	`int s = 5; s -= 3;`	`s = 2`
`*=`	乘赋值	`int t = 5; t *= 3;`	`t = 15`
`/=`	除赋值	`int u = 10; u /= 2;`	`u = 5`
`%=`	取余赋值	`int v = 7; v %= 3;`	`v = 1`
位运算符
`&`	按位与、逻辑与	`int w = 5 & 3;`	`w = 1`
`\|`	按位或、逻辑或	`int x = 5 \| 3;`	`x = 7`
`^`	按位异或	`int y = 5 ^ 3;`	`y = 6`
`~`	按位取反	`int z = ~5;`	`z = -6`
`<<`	左移	`int aa = 5 << 1;`	`aa = 10`
`>>`	右移	`int bb = 5 >> 1;`	`bb = 2`
`>>>`	无符号右移	`int cc = 5 >>> 1;`	`cc = 2`
三元运算符
`?:`	条件运算符（三元运算符）	`int dd = (5 > 3) ? 10 : 20;`	`dd = 10`
instanceof	检查对象是否为某个类的实例	`String str = "Hello";` `boolean ee = str instanceof String;`	`ee = true`

📌算数运算符

+、-、*、÷、/、++、--

🌟+

普通操作

加法运算跟我们平时的计算并无二致

示例代码：
int a = 1;
int b = 2;
int sum = a + b;//sum = 3
需要注意的是+的字符串操作和+的字符操作

字符串操作

当+操作中出现字符串时，此时就是字符串的连接符，会将前后的数据进行拼接，并产生一个新的字符串。
当连续进行+操作时，从左到右逐个执行的。

示例代码：
String a = 1 + 2 + "abc" + 2 + 1;
System.out.println(a);   //3abc21
代码解析：

1 + 2，得到3
3 + "abc"，得到"3abc"
"3abc" + 2，得到"3abc2"
"3abc2" + 1，得到最终结果"3abc21"

注意：有字符串参与的运算都会得到一个新的字符串

字符操作

当+操作中出现了字符，会拿着字符到计算机内置的ASCII码表中去查对应的数字，然后再进行计算。

示例代码：
char c = 'a';
int result = c + 0;
System.out.println(result);//97
记忆（字符a与A对应的ASCII码表值）：

'a' —— 97

'A' —— 65

不过在这，我也给大家准备了ASCII码表，方便大家查询

ASCII码表

Dec Char Dec Char Dec Char Dec Char
32 ' ' 48 0 64 @ 80 P
33 ! 49 1 65 A 81 Q
34 " 50 2 66 B 82 R
35 # 51 3 67 C 83 S
36 $ 52 4 68 D 84 T
37 % 53 5 69 E 85 U
38 & 54 6 70 F 86 V
39 ' 55 7 71 G 87 W
40 ( 56 8 72 H 88 X
41 ) 57 9 73 I 89 Y
42 * 58 : 74 J 90 Z
43 + 59 ; 75 K 91 [
44 , 60 < 76 L 92 \
45 - 61 = 77 M 93 ]
46 . 62 > 78 N 94 ^
47 / 63 ? 79 O 95 _
96 ` 112 p 128 144
97 a 113 q 129 145
98 b 114 r 130 é 146
99 c 115 s 131 â 147
100 d 116 t 132 ä 148
101 e 117 u 133 à 149
102 f 118 v 134 ç 150
103 g 119 w 135 ê 151
104 h 120 x 136 ë 152
105 i 121 y 137 è 153
106 j 122 z 138 ï 154
107 k 123 { 139 î 155
108 l 124 | 140 ì 156
109 m 125 } 141 Ä 157
110 n 126 ~ 142 Å 158
111 o 127 DEL 143 É 159

Dec	Char	Dec	Char	Dec	Char	Dec	Char
32	' '	48	0	64	@	80	P
33	!	49	1	65	A	81	Q
34	"	50	2	66	B	82	R
35	#	51	3	67	C	83	S
36	$	52	4	68	D	84	T
37	%	53	5	69	E	85	U
38	&	54	6	70	F	86	V
39	'	55	7	71	G	87	W
40	(	56	8	72	H	88	X
41	)	57	9	73	I	89	Y
42	*	58	:	74	J	90	Z
43	+	59	;	75	K	91	[
44	,	60	<	76	L	92	\
45	-	61	=	77	M	93	]
46	.	62	>	78	N	94	^
47	/	63	?	79	O	95	_
96	`	112	p	128		144
97	a	113	q	129		145
98	b	114	r	130	é	146
99	c	115	s	131	â	147
100	d	116	t	132	ä	148
101	e	117	u	133	à	149
102	f	118	v	134	ç	150
103	g	119	w	135	ê	151
104	h	120	x	136	ë	152
105	i	121	y	137	è	153
106	j	122	z	138	ï	154
107	k	123	{	139	î	155
108	l	124	\|	140	ì	156
109	m	125	}	141	Ä	157
110	n	126	~	142	Å	158
111	o	127	DEL	143	É	159

🌟- 、*

减法和乘法都遵循基本的数学运算规则

减法示例代码：
int c = 10;
int d = 4;
System.out.println(c - d); //6
乘法示例代码：
int c = 10;
int d = 4;
System.out.println(c * d); //40

🌟/、%

/

/是除的符号，求商

在整数的除法运算上，除法的运算依然遵循我们常用的数学运算
但是在小数的运算中，Java中除法的运算就和我们实际生活中的数学运算有所不同了
整数相除结果只能得到整除，如果结果想要是小数，必须要有小数参数。

示例代码：
System.out.println( 10 / 3);//3
System.out.println(10.0 / 3);//3.3333333333333335
小数直接参与运算，得到的结果有可能是不精确的。

%

%是取模符号，也就是求余数，为什么把%和÷放在一起讲呢？因为%做的也是除法，只是在最后取得是余数而已

示例代码：
System.out.println(10 % 2);//0
System.out.println(10 % 3);//1

🌟自增自减运算符++、--

++  自增运算符【++：就是把变量里面的值+1】
--  自减运算符【--：就是把变量里面的值-1】
使用方式：
放在变量的后面，我们叫做后++。比如：a++【先运算后++】
示例：
int a = 10;
int b = a++; //b = 10, a = 11
放在变量的前面，我们叫做先++。比如：++a【先++后运算】
示例：
int a = 10;
int b = ++a; //b = 11, a = 11
不管是先++，还是后++。单独写在一行的时候，运算结果是一模一样的。
示例：
a++;
++a;

📌关系运算符

也就是比较运算符，本质就是表达式左右两边进行了判断

==、!=、>、<、>=、<=

各关系运算符的作用与返回值
符号解释
== 就是判断左边跟右边是否相等，如果成立就是true，如果不成立就是false
!= 就是判断左边跟右边是否不相等，如果成立就是true，如果不成立就是false
> 就是判断左边是否大于右边，如果成立就是true，如果不成立就是false
>= 就是判断左边是否大于等于右边，如果成立就是true，如果不成立就是false
< 就是判断左边是否小于右边，如果成立就是true，如果不成立就是false
<=
就是判断左边是否小于等于右边，如果成立就是true，如果不成立就是false

符号	解释
==	就是判断左边跟右边是否相等，如果成立就是true，如果不成立就是false
!=	就是判断左边跟右边是否不相等，如果成立就是true，如果不成立就是false
>	就是判断左边是否大于右边，如果成立就是true，如果不成立就是false
>=	就是判断左边是否大于等于右边，如果成立就是true，如果不成立就是false
<	就是判断左边是否小于右边，如果成立就是true，如果不成立就是false
<=	就是判断左边是否小于等于右边，如果成立就是true，如果不成立就是false

总结：
关系运算符最终的结果一定是布尔类型的。要么是true，要么是false

示例代码

==等于（Java中的等号是由两个=组成的）

public class Main {
    public static void main(String[] args) {
        int a = 100;
        int b = 100;
        System.out.println(a == b); // 输出: true
    }
}

!=不等号

public class Main {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println(a != b); // 输出: true
    }
}

>大于号

public class Main {
    public static void main(String[] args) {
        int a = 10;
        int b = 5;
        System.out.println(a > b); // 输出: true
    }
}

>=大于等于号

public class Main {
    public static void main(String[] args) {
        int a = 5;
        int b = 5;
        System.out.println(a >= b); // 输出: true
    }
}

<小于号

public class Main {
    public static void main(String[] args) {
        int a = 3;
        int b = 7;
        System.out.println(a < b); // 输出: true
    }
}

<=小于等于号

public class Main {
    public static void main(String[] args) {
        int a = 9;
        int b = 10;
        System.out.println(a <= b); // 输出: true
    }
}

📌逻辑运算符

我们可以把一些位运算符加入到此段内一起讨论

&、|、^、!、&&、||

🌟& 与 |

&：逻辑与（而且）

两边都为真，结果才是真，只要有一个为假，那么结果就是假。

代码示例：
// &  //两边都是真，结果才是真。
System.out.println(true & true);//true
System.out.println(false & false);//false
System.out.println(true & false);//false
System.out.println(false & true);//false
|：逻辑或（或者）

两边都为假，结果才是假，只要有一个为真，那么结果就是真。

代码示例：
// | 或  //两边都是假，结果才是假，如果有一个为真，那么结果就是真。
System.out.println(true | true);//true
System.out.println(false | false);//false
System.out.println(true | false);//true
System.out.println(false | true);//true

🌟短路逻辑运算符&& 与 ||

&&：

运算结果跟&是一模一样的，只不过具有短路效果。

||：

运算结果跟|是一模一样的。只不过具有短路效果。

那什么是短路效果呢？

&：两边都为真，结果才是真，只要有一个为假，那么结果就是假。

我们程序从左到右执行，左边的为假就可以不用对右边进行运算了，整个的结果就为假

|：两边都为假，结果才是假，只要有一个为真，那么结果就是真。

我们程序从左到右执行，左边的为真就可以不用对右边进行运算了，整个的结果就为真

逻辑核心：

当左边不能确定整个表达式的结果，右边才会执行。

当左边能确定整个表达式的结果，那么右边就不会执行了。

作用：

&& 和 & 、||和|的运行结果都是一模一样的。

但是短路逻辑运算符可以提高程序的运行效率。

建议：

最为常用（推荐使用）： &&、 ||

🌟！取反

！是取反，也叫做非。

计算规则：false取反就是true，true取反就是false

温馨提示：取反最多只用一个。

代码示例：
System.out.println(!false);//true
System.out.println(!true);//false

System.out.println(!!false);//注意点：取反最多只用一个。

🌟^ 异或

计算规则：如果两边相同，结果为false，如果两边不同，结果为true

代码示例：

 //左右不相同，结果才是true，左右相同结果就是false
System.out.println(true ^ true);//false
System.out.println(false ^ false);//false
System.out.println(true ^ false);//true
System.out.println(false ^ true);//true

📌赋值运算符

=、+=、-=、*=、/=、%=

🌟=

这是我们编程中最常用的赋值运算符，注意这个不是等于号！

运算过程：就是把等号右边的结果赋值给左边的变量

示例代码：

//1.最为简单的赋值运算符用法
int a = 10;//就是把10赋值给变量a
System.out.println(a);

//2.如果等号右边需要进行计算。
int b = 20;
int c = a + b;//先计算等号右边的，把计算的结果赋值给左边的变量
System.out.println(c);

//3.特殊的用法
a = a + 10;//先计算等号右边的，把计算的结果赋值给左边的变量
System.out.println(a);//20

🌟扩展赋值运算符

+=、-=、*=、/=、%=

运算规则：就是把左边跟右边进行运算，把最终的结果赋值给左边，对右边没有任何影响。

示例代码：
int a = 10;
int b = 20;
a += b;//把左边和右边相加，再把最终的结果赋值给左边，对右边没有任何影响
// 相当于 a = a + b;
System.out.println(a);//30
System.out.println(b);//20
注意：扩展的赋值运算符中隐层还包含了一个强制转换。

以+=为例。

a += b ;实际上相当于 a = (byte)(a + b);

因为byte类型在运算时会自动强转为int
byte a = 10;
byte b = 20;
//a += b;
a = (byte)(a + b);
System.out.println(a);//30

📌三元运算符

又叫做：三元表达式或者问号冒号表达式。作用有点类似于if，但是if能实现的功能更为全面

格式：关系表达式？表达式1 ：表达式2 ；

计算规则：

计算关系表达式的值。

如果关系表达式的值为真，那么执行表达式1。

如果关系表达式的值为假，那么执行表达式2。

注意点：

三元运算符的最终结果一定要被使用，要么赋值给一个变量，要么直接打印出来。

示例：
//需求：求两个数的较大值
int a = 10;
int b = 20;

//注意点：
//三元运算符的最终结果一定要被使用。
//要么赋值给一个变量，要么直接输出。
int max =  a > b ? a : b ;
System.out.println(max);

📌<<、>>

🌟<<：向左移动，低位补0

如：int a = 200;

a << 2

把我们定义的整数转换为二进制的形式展示出来：

0000 0000 0000 0000 0000 0000 1100 1000

向左移动，低位补0，得到：

00 | 00 0000 0000 0000 0000 0000 1100 1000 00 | = 800

最后面两个红色的0就是整体向左移动两位补上去的，将其转换为十进制为：800

相当于位移一位即×2

由此得 a << n 等于 a * 2^n

🌟>>：向右移动，高位补0 ，如果本来是负数则最高位补1

如：int a = 200;

a >> 2

把我们定义的整数转换为二进制的形式展示出来：

0000 0000 0000 0000 0000 0000 1100 1000

向右移动，高位补0 ，如果本来是负数则最高位补1，得到：

00 | 0000 0000 0000 0000 0000 0000 1100 10 | 00 = 50

最前面两个红色的0就是整体向右移动两位补上去的，将其转换为十进制为：50

相当于位移一位即÷2

由此得 a >> n 等于 a * 1/2^n

💻小结

通过本篇文章的学习，我们深入了解了Java编程中的各种运算符及其使用方法。
文章从最基础的运算符概念入手，逐步介绍了算术运算符、关系运算符、逻辑运算符等常用运算符的使用场景与具体功能，并附上了详细的运算符一览表。
同时，文章还涉及了自增自减运算符、三元运算符、位移运算符等进阶内容，帮助读者更好地掌握Java表达式的编写和优化。

🌷🌷🌷欢迎点赞、评论、收藏和关注~🌷🌷🌷

Dec	Char	Dec	Char	Dec	Char	Dec	Char
32	' '	48	0	64	@	80	P
33	!	49	1	65	A	81	Q
34	"	50	2	66	B	82	R
35	#	51	3	67	C	83	S
36	$	52	4	68	D	84	T
37	%	53	5	69	E	85	U
38	&	54	6	70	F	86	V
39	'	55	7	71	G	87	W
40	(	56	8	72	H	88	X
41	)	57	9	73	I	89	Y
42	*	58	:	74	J	90	Z
43	+	59	;	75	K	91	[
44	,	60	<	76	L	92	\
45	-	61	=	77	M	93	]
46	.	62	>	78	N	94	^
47	/	63	?	79	O	95	_
96	`	112	p	128		144
97	a	113	q	129		145
98	b	114	r	130	é	146
99	c	115	s	131	â	147
100	d	116	t	132	ä	148
101	e	117	u	133	à	149
102	f	118	v	134	ç	150
103	g	119	w	135	ê	151
104	h	120	x	136	ë	152
105	i	121	y	137	è	153
106	j	122	z	138	ï	154
107	k	123	{	139	î	155
108	l	124	\|	140	ì	156
109	m	125	}	141	Ä	157
110	n	126	~	142	Å	158
111	o	127	DEL	143	É	159

Dec	Char	Dec	Char	Dec	Char	Dec	Char
32	' '	48	0	64	@	80	P
33	!	49	1	65	A	81	Q
34	"	50	2	66	B	82	R
35	#	51	3	67	C	83	S
36	$	52	4	68	D	84	T
37	%	53	5	69	E	85	U
38	&	54	6	70	F	86	V
39	'	55	7	71	G	87	W
40	(	56	8	72	H	88	X
41	)	57	9	73	I	89	Y
42	*	58	:	74	J	90	Z
43	+	59	;	75	K	91	[
44	,	60	<	76	L	92	\
45	-	61	=	77	M	93	]
46	.	62	>	78	N	94	^
47	/	63	?	79	O	95	_
96	`	112	p	128		144
97	a	113	q	129		145
98	b	114	r	130	é	146
99	c	115	s	131	â	147
100	d	116	t	132	ä	148
101	e	117	u	133	à	149
102	f	118	v	134	ç	150
103	g	119	w	135	ê	151
104	h	120	x	136	ë	152
105	i	121	y	137	è	153
106	j	122	z	138	ï	154
107	k	123	{	139	î	155
108	l	124	\|	140	ì	156
109	m	125	}	141	Ä	157
110	n	126	~	142	Å	158
111	o	127	DEL	143	É	159