写在前面：
🎈 恭喜你发现了一片新的天地，来到阿亮的世界欸，欢迎欢迎 🎉 🎉 🎉
🍬 亮亮我欸，是一名在学C++、JAVA、HTML的大一菜菜捏，新的一年，会不定期更新Java或C++、stl及其算法之间的文章 ✍ ✍ ✍
🚩 首先，感谢您能认可我的文章点进来，我们又一次相遇在CSDN了嘿！
🎇 再次，本人郑重承诺我是一名爱国敬业、诚信友善、热爱人民、不沾黄赌毒、有理想有责任有担当、能吃苦肯奋斗的新时代好青年，大家不要害怕，欢迎大家与我交朋友 😉
❓ 接着，由于亮亮刚写博客不久，本文肯定有遗漏疏忽的地方，欢迎大家批评指正欸 🥳 🥳
🧨 最后，新的一年，愿你我都远离疫病，敢于直面攀登过程中的流言蜚语，亦不怕掉落低谷时的迷茫彷徨。让我们一起加油，共同进步叭~
好了好了，闲话少说，步入正题，这是俺的第三天博客，也是java的第二章叭——运算符和标点符号 🤗 🤗 🤗
————————————————
版权声明：本文为CSDN博主「努力的阿亮」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接： https://blog.csdn.net/m0_73612212/article/details/128627784
1.分类
在java中，一共有38个运算符
按功能分：算术运算符、赋值运算符、比较运算符、逻辑运算符、条件运算符、Lambda运算符
分类 | 运算符 |
算术运算符（7个）（计算的） | +、-、*、/、%、++、-- |
赋值运算符（12个） （将值赋值给变量的） | =、+=、-=、*=、/=、%=、>>=、 <<=、>>>=、&=、|=、^=等 |
关系运算符（6个）（比较的） | >、<、==、!=、>=、<= |
逻辑运算符（2个）（连接语句的） | &、|、^、!、&&、| | |
条件运算符（2个）（条件判断的） | (条件表达式)?结果1:结果2 |
位运算符（7个） （二进制数进行改变的） | &、^、~、 <<、>>、>>> |
Lambda运算符（1个）（转换的） | -> |
按操作数个数分为：一元运算符（单目运算符）、二元运算符（双目运算符）、三元运算符（三目运算符）
分类 | 运算符 |
一元运算符（单目运算符） | +、-、++、--、！、~ |
二元运算符（双目运算符） | 除了一元、三元其他都是二元运算符 |
三元运算符（三目运算符） | (条件表达式)?结果1:结果2 |
2.算术运算符
算术运算符 | 符号解释 |
+ | ①加法运算 ②字符串连接 ③正号 |
- | ①减法运算 ②负号 |
* | 乘法运算 |
/ | 除法运算 （注意：整数/整数=整数） |
% | 求余/取模运算 （注意：余数的符号只看被除数） |
++、-- | 自增、自减运算 （相当于+=1、-=1） |
2.1加号的两种用法
用法
①两边都是数值，即为算术相加
②至少有一边是字符串，即为拼接的意思
2.练习
那来看个小例题叭~
System.out.println(1+2+3+"4"+5+6);
//求输出多少
2.2自加自减运算
2.2.1 理解
++运算，变量自己时＋1.反之，--运算，变量自己时-1；用法一致。
2.2.2使用
变量在单独运算的前后，前++和后++，变量是一样的；
单独使用：无论前++还是后++，变量值都+1；
复合使用：
①前++：先自身+1，再取值
②后++：先取值，再自身+1
2.2.3例题
① 例题1
int x=3;
int y=++x;
System.out.print("x = "+ x); //x=?
System.out.print("y = "+ y); //x=?
int a=4;
int b=a++;
System.out.print("a = "+ a); //a=?
System.out.print("b = "+ b); //b=?
做完上面这个小练习，不如试试下面这个进阶的叭~有难度的哈
②例题2
int z=5;
System.out.print(z++);//输出多少
int x=5;
System.out.print(++x);//输出多少
如果这个都难不倒你的话，我可要上强度啦~
③例题3
int a=1;
a=a++;
System.out.println(a);
最后一个题啦，面试真题哦，有些难，加油加油！
④例题4
int i=1;
int j= i++ + ++i * i++
Systrm.out.println(j);
//一些类似的练习，可选择性参考
public static void main(String[] args) {
m5();
}
public static void m5(){
int i = 0; // 1 0
int result = ++i/--i;
System.out.println("result="+result);
//ArithmeticException: / by zero 1/0 异常
}
public static void m4(){
int i = 1;
// i = 1 2 3 4 5 j = 14
// 2 2 4 4
int j = ++i + i++ * ++i + i++;
System.out.println("i = " + i);
System.out.println("j = " + j);
}
public static void m3() {
int i = 1;
int j = i++; //j=1 2 1 i=2 3 2
// = 2 * 2 + 2 * 2
int k = i++ * ++j + --i * j--;
System.out.println("i = " + i); //2
System.out.println("j = " + j); //1
System.out.println("k = " + k); //8
}
public static void m2() {
int i = 1;
int j = i++; // j = 1 i=2
// i取值2 i = 3
// j取值2 j = 2
// i取值4 i = 4
// j取值2 j = 3
// k = 2 * 2 + 4 * 2 = 12
int k = i++ * ++j + ++i * j++;
System.out.println("i = " + i); //4
System.out.println("j = " + j); //3
System.out.println("k = " + k); //12
}小结：
++ 在前，先++，再赋值
++在后，先赋值，再++
3.关系运算符/比较运算符
关系运算符 | 符号解释 |
< | 左<右，返回true；左>=右，返回false |
> | 左>右，返回true；左<=右，返回false |
<= | 左<=右，返回true；左>右，返回false |
>= | 左>=右，返回true；左<右，返回false |
== | 左等于右，返回true；左不等于右，返回false |
!= | 左不等于右，返回true；左等于右，返回true |
3.1理解
比较运算符：两个数据之间相互比较，结果返回true/false
>、<、>=、<=不支持boolean、String类型
==和!=支持boolean和String
3.2例题
4.逻辑运算符
逻辑运算符 | 符号解释 | 符号特点 |
& | 与，且 | 有一个是flase，则返回false |
| | 或 | 有一个是true，则返回true |
^ | 异或 | 相同则返回flase，不同则返回true |
! | 非 | 非flase则返回true，非true则返回false |
&& | 双与，短路与 | 意为"和"，当左边为flase时，则右边不执行 |
|| | 双或，短路或 | 意为"或"，当左边为true时，则右边不执行 |
4.1理解
逻辑运算符，用来连接两个布尔类型的运算符（!除外），运算结果也是boolean值true/false
&&和&区别，||和|区别：
&&和&区别：
&&和&结果一样，但&&有短路效果，左为false，右不执行。而&左右都执行
||和|区别：
||和|结果一样，但||有短路效果，左为true，右不执行。而&左右都执行
逻辑与：&true & true 结果是true
true & false 结果是false
false & true 结果是false
false & false 结果是false
只有两个边都是true，结果才为true。
逻辑或：|
true | true 结果是true
true | false 结果是true
false | true 结果是true
false | false 结果是false
只要有一边是true，结果就为true。
逻辑非：!
!true 变为false
!false 变为true
逻辑异或：^
true | true 结果是false
true | false 结果是true
false | true 结果是true
false | false 结果是false
只有两边不一样，一个是true，一个是false，结果才为true。
短路与：&&
true && true 结果是true
true && false 结果是false
false && ? 结果是false
false && ? 结果是false
只有两个边都是true，结果才为true。
但是它如果左边已经是false，右边不看。这样的好处就是可以提高效率。
短路或：||
true || ？ 结果是true
true || ？ 结果是true
false || true 结果是true
false || false 结果是false
只要有一边是true，结果就为true。
但是它如果左边已经是true，右边就不看了。这样的好处就是可以提高效率。
特殊：
（1）逻辑运算符的操作数必须是boolean值
（2）逻辑运算符的结果也是boolean值
4.2例题
4.2.1例题①
public class Test01_SuanShu_LuoJi {
//逻辑运算符
public static void main(String[] args) {
// & |
int a = 3 ,b = 4 , c = 5;
System.out.println(a>b & b<c ); // false true // false
System.out.println(a<b & b<c ); // true true // true
System.out.println(a>b | b<c ); // false true //true
System.out.println(a<b | b<c ); // true true // true
System.out.println(a>b | b>c ); // false false // false
System.out.println(!(a>b)); //false true
System.out.println(!(a<b)); //true false
System.out.println(a>b ^ b<c ); // false true // true
System.out.println(a<b ^ b<c ); // true true // false
//短路&&
//左边出现false 右边不用执行
//短路||、
//左边出现true 右边不用执行
System.out.println("--------------");
int x = 10;
int y = 10;
//System.out.println(x!=y && x-- == 10 ); // false
System.out.println(x==10 && x-- == 10 ); // false
System.out.println(x);
System.out.println(10!=y || y-- == 10 ); // true
System.out.println(y);
}
}4.2.2例题②
public class Test01_SuanShu_ex02 {
//获取一个四位数的个位，十位，百位，千位
public static void main(String[] args) {
m4_1();
}
public static void m4_1 () {
boolean x = true;
boolean y = false;
short z = 42;
if(y=true)
if((z++==42)&&(y==true)) //true z=43
z++; // z=44
if((x=false) || (++z==45)) z++; //z=46
System. out.println("z="+z); //z=46
}
public static void m4(){
boolean x = true;
boolean y = false;
short z = 42;
// z=43 true false = false
if((z++==42)&&(y==true)) z++;
//false || false z=44
if((x=false) || (++z==45)) z++;
System. out.println("z="+z); //z = 44
}
public static void m3_3(){
int x = 1,y = 1;
if(x++==1 || ++y==1){ //x=2 true
x =7;
}
System.out.println("x="+x+",y="+y); //x=7 y=1
}
public static void m3_2(){
int x = 1,y = 1;
if(x++==1 | ++y==1){ // true x=2 false y=2
x =7;
}
System.out.println("x="+x+",y="+y); //x=7 y=2
}
public static void m3_1(){
int x = 1,y = 1;
//x = 1
if(x++==2 && ++y==2){
x =7;
}
System.out.println("x="+x+",y="+y); //x=2 y=1
}
public static void m3_0(){
int x = 1;
int y = 1;
if(x++==2 & ++y==2){ //false x=2 y=2
x =7;
}
System.out.println("x="+x+",y="+y); //x=2 y=2
}
public static void m2(){
int a = 1;
int b = 2;
int c = 0;
boolean flag = false;
if(flag=true){ // true
c = a++ + b; //执行
// a 取 1 a=2
// c = 1+2 = 3
}
if(flag=false){ // false
c = ++a - b;
}
System.out.println("a = " + a); //2
System.out.println("b = " + b); //2
System.out.println("c = " + c); //3
}
public static void m1(){
int a = 1;
int b = 2;
int c = 0;
boolean flag = false;
if(flag==true){
c = a++ + b; //不会执行
}
if(flag==false){ //true
c = ++a - b; //会执行
// a = 2 b = 2
// c = 0;
}
System.out.println("a = " + a); //2
System.out.println("b = " + b); //2
System.out.println("c = " + c); //0
}
}5.条件运算符
5.1理解
格式：条件表达式？结果1（true）：结果2（false）
赋值使用
结果1和结果2类型相同
最终结果类型>结果类型
5.2例题
public static void main(String[] args) {
int i = (1==2 ? 100 : 200);
System.out.println(i);//200
int j = (3<=4 ? 500 : 600);
System.out.println(j);//500
}public class ConditionOperator{
public static void main(String[] args){
//判断两个变量a,b谁大，把大的变量赋值给max
int a = 2;
int b = 2;
int max = a >= b ? a : b;
//如果a>=b成立，就取a的值赋给max，否则取b的值赋给max
System.out.println(max);
boolean marry = false;
System.out.println(marry ? "已婚" : "未婚" );
}
}6.位运算符
位运算符 | 符号解释 |
& | 按位与，当两位相同时为1时才返回1 |
| | 按位或，只要有一位为1即可返回1 |
~ | 按位非，将操作数的每个位（包括符号位）全部取反 |
^ | 按位异或。当两位相同时返回0，不同时返回1 |
<< | 左移运算符 |
>> | 右移运算符 |
>>> | 无符号右移运算符 |
6.1理解
位运算符的运算过程都是基于补码运算，但是看结果，我们得换成原码，再换成十进制看结果
从二进制到十进制都是基于原码
正数的原码反码补码都一样，负数原码反码补码不一样
byte,short,char在计算时按照int类型处理
那该如何区分& , | , ^是逻辑运算符还是位运算符呢？
答案是如果操作数是boolean类型，就是逻辑运算符，如果操作数是整数，那么就位运算符。
6.2规则及示例
- 左移操作符:<<
运算规则:左移几次方就相当于×2的几次方
注意:在左移数n超过该数据类型的总位数时，相当于左移（n-总位数）位byte,short,char在计算时按照int类型处理
eg1：8<<4 <=> 8*(2^4)=8*16=128
eg2:-8<<4 <=> -8*(2^4)=-8*16=-128
- 右移操作符：>>
快速运算：类似于除以2的n次，如果不能整除，向下取整
eg1:69>>4 类似于 69/2的4次=69/16=4
eg2：-69>>4类似于-69/2的4次=-69/16=-5
- 无符号右移：>>>
运算规则：往右移动后，左边空出来的位直接补0，不看符号位
正数：和右移一样
负数：右边移出去几位，左边补几个0，结果变为正数
eg1：69>>>4 <=> 69/2的4次 <=> 69/16 =4
eg2：-69>>>4 结果：268435451
- 按位与：&
运算规则：对应位都是1才为1,其他为0
1 & 1 结果为1
1 & 0 结果为0
0 & 1 结果为0
0 & 0 结果为0
eg1：9&7 = 1
eg2：-9&7 = 7
- 按位或：|
运算规则：对应位只要有1即为1
1 | 1 结果为1
1 | 0 结果为1
0 | 1 结果为1
0 & 0 结果为0
eg1：9|7 结果： 15
eg2：-9|7 结果： -9
- 按位异或：^
运算规则：对应位一个为1一个为0，才为1
1 ^ 1 结果为0
1 ^ 0 结果为1
0 ^ 1 结果为1
0 ^ 0 结果为0
eg1：9^7 结果为14
eg2：-9^7 结果为-16
- 按位取反：~
运算规则：~0就是1
~1就是0
eg1：~9 结果：-10
eg2：~-9 结果：8
7.赋值运算符
运算符 | 符号解释 |
= | 将右边的常量值/变量值/表达式的值，赋值给左边的变量 |
+= | 将左边变量的值和右边的常量值/变量值/表达式的值进行相加，最后将结果赋值给左边的变量 |
-= | 将左边变量的值和右边的常量值/变量值/表达式的值进行相减，最后将结果赋值给左边的变量 |
*= | 将左边变量的值和右边的常量值/变量值/表达式的值进行相乘，最后将结果赋值给左边的变量 |
/= | 将左边变量的值和右边的常量值/变量值/表达式的值进行相除，最后将结果赋值给左边的变量 |
%= | 将左边变量的值和右边的常量值/变量值/表达式的值进行相模，最后将结果赋值给左边的变量 |
<<= | 将左边变量的值左移右边常量/变量值/表达式的值的相应位，最后将结果赋值给左边的变量 |
>>= | 将左边变量的值右移右边常量/变量值/表达式的值的相应位，最后将结果赋值给左边的变量 |
>>>= | 将左边变量的值无符号右移右边常量/变量值/表达式的值的相应位，最后将结果赋值给左边的变量 |
&= | 将左边变量的值和右边的常量值/变量值/表达式的值进行按位与，最后将结果赋值给左边的变量 |
|= | 将左边变量的值和右边的常量值/变量值/表达式的值进行按位或，最后将结果赋值给左边的变量 |
^= | 将左边变量的值和右边的常量值/变量值/表达式的值进行按位异或，最后将结果赋值给左边的变量 |
注意！！！
扩展赋值运算符在将最后的结果赋值给左边的变量前，多做了一步强制类型转换。
所有的赋值运算符的=左边一定是一个变量
8.运算符优先顺序（重点的！）
++ -- ~ ！ |
|
× / % | |
＋ - | |
<< >> >>> | |
== != | |
& | |
^ | |
| | |
&& | |
|| | |
? : | |
= *= /= %= | |
+= -= <<= >>= | |
>>>= &= ^= |= |
8.1提示说明：
表达式不要太复杂
先算的使用()
8.2口诀：
单目运算排第一；
乘除余二加减三；
移位四，关系五；
等和不等排第六；
位与、异或和位或；
短路与和短路或；
依次从七到十一；
条件排在第十二；
赋值一定是最后；
9.标点符号
小括号() 用于强制类型转换、表示优先运算表达式、方法参数列表
大括号{} 用于数组元素列表、类体、方法体、复合语句代码块边界符
中括号[] 用于数组
分号; 用于结束语句
逗号, 用于多个赋值表达式的分隔符和方法参数列表分隔符
英文句号.用于成员访问和包目录结构分隔符
英文省略号...用于可变参数
@ 用于注解
双冒号::用于方法引用
标点符号 | 中文名 | 用法 |
() | 小括号 | 用于强制类型转换、表示优先运算表达式、方法参数列表 |
[] | 中括号 | 用于数组 |
{} | 大括号 | 用于数组元素列表、类体、方法体、复合语句代码块边界符 |
; | 英文分号 | 用于结束语句 |
, | 英文句号 | 用于多个赋值表达式的分隔符和方法参数列表分隔符 |
. | 英文省略号 | 用于成员访问和包目录结构分隔符 |
… | 英文省略号 | …用于可变参数 |
@ | 艾特号 (非官方，我自己这么叫的哈哈哈) | 用于注解 |
:: | 双冒号 | 用于方法引用 |
写在最后
原创不易，希望各位大佬多多支持哈~
一连两连三连的我也都会互访的哦 👉
感谢大家，一起加油！
1320
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
