java的几种运算符以及优先级

运算符

1.算数运算符

+、-、 *、 / 、 % 、++、 --、
使用方式：单独使用 参与计算
当++、–出现在操作数的后面时，先传值再自加/自减
当++、–出现在操作数的前面时，先自加/自减再赋值
byte、short、char做++/–时。底层会默认添加强转类型转换

2.赋值运算符

把右边的值赋值给左边
扩展赋值运算符（底层强制类型转换）
+=、 -=、 *=、 /=、 %=、 &=（按位与等）、 |=、 ^=、>>=（右移等）、 <<=（左移等） 、>>>=（无符号右移等）
Java不支持连等定义 支持连等赋值
右边变量的值改变了不会影响左边已经编译好的值

class FuZhi{
public static void main(String[] args) {
//定义变量;
/*int a=3;
int b=4;
a+=b;//a=a+b;*/
////
//byte b=2;
////b=b+3;b+3位int类型
//b+=3;//b=b+3;底层默认添加强制类型转换
//System.out.println(b);

//支持定义形式
//int a=1,b=2,c=3;
//不支持连等定义
//int a=b=c=3;
//支持连等赋值
//展开从右往左计算
//b=3+3=3-=3=3*5=15
//b=3+3=3-=15=-12
//b=3+3=-12=-9
int a=3;
/*int b=a+=a-=a*=5;
System.out.println(b);//-9*/
//b=3+=3-=3*=3++
//右边变量的值改变了不影响左边已经编译好的值
int b=a+=a-=a*=a++;
System.out.println(b);//-3

}
}

3.关系（比较）运算符

结果值一定是布尔值
==、！=、>、<、>=、<=、

class BiJiao{
public static void main(String[] args) {
//操作==;
System.out.println(2==4);
//操作>=
System.out.println(5>=0);
//操作！=
System.out.println(4!=5);

}

}

4.逻辑运算符

（用于连接左右两边布尔值）
表示 名字 运算规律
& 逻辑与 一假则假
| 逻辑或 一真则真
^ 逻辑异或 相同为假，不同为真
！ 逻辑非 结果取反（当出现偶数个不变，奇数个取反）
&& 双与 同逻辑与
|| 双或 同逻辑或
双与和逻辑与的区别：双与当左边出现false时，右边不执行（短路效果），但是逻辑与都会执行
双或和逻辑或的区别：双或当左边出现true时，右边不执行（短路效果），但是逻辑或都会执行

a++==b   先比较再自加

//操作&
System.out.println((a>b)&(b>c));//false&false     false
System.out.println((a>b)&(b<c));//false&true    false
System.out.println((a<b)&(b>c));//true&false   false
System.out.println((a<b)&(b<c));//true&true     true

//操作|
System.out.println("-------------------------------");
System.out.println((a>b)|(b>c));//false&false     false
System.out.println((a>b)|(b<c));//false&true    true
System.out.println((a<b)|(b>c));//true&false   true
System.out.println((a<b)|(b<c));//true&true     false

//操作^
System.out.println("-------------------------------");
System.out.println((a>b)^(b>c));//false&false    false
System.out.println((a>b)^(b<c));//false&true    true
System.out.println((a<b)^(b>c));//true&false   true
System.out.println((a<b)^(b<c));//true&true     true

//操作！
System.out.println("------------------------");
System.out.println(!(!(b>c)));//false

//操作&&
//和逻辑与的运算规律一致
System.out.println("---------------------------");

System.out.println((a>b)&&(b>c));//false&&false     false
System.out.println((a>b)&&(b<c));//false&&true    false
System.out.println((a<b)&&(b>c));//true&&false   false
System.out.println((a<b)&&(b<c));//true&&true     true

System.out.println("----------------------------------");
//||出现在&&的左边且||出现短路
//就会把后面的内容以及&&一并短路掉
System.out.println((true)||(a++==b)&&(b>c--));//true
System.out.println(a);//1
System.out.println(c);//3

5.位运算符

数据转成二进制的补码形式
表示 名称 运算规律
& 按位与 遇0则0 任意整数&1==0一定是偶数 任意整数&正数 一定是正数
| 按位或 遇1则1 任意整数|0 一定是本身 任意整数|负数 一定是负数
^ 按位异或 相同则0，不同则1
~ 按位取反 所有位按位取反

右移        当正数右移时，右移几位就在最左边（最高位）补上几个0，负数补1

<< 左移 无论正负数进行左移时，左移几位就在最右边补上几个0

无符号右移      无论正负数进行右移时，左移几位就在最左边补上几个0

末尾是0为偶数，末尾是1为奇数
按位异或的扩展：当一个整数按位异或上另一个整数两次时，结果还是本身

需求：两个数值交换 效率高低：按位异或>求和>中间变量
1.中间变量（可以是任意数 常用）

2.按位异或（只针对整数）

3.求和（一般是整数)

class WeiSuan{
public static void main(String[] args) {
//定义变量;
int a=2;
int b=3;
//操作&
System.out.println(a&b);//2
//操作|
System.out.println(a|b);//3
//操作^
System.out.println(a^b);//1
//操作~
System.out.println(a~b);//-3

}
}

/*
00000000  00000000  00000000   00000010  int 2
//操作&  遇0则0  任意整数&1==0一定是偶数
//任意整数&正数   一定是正数
00000000  00000000  00000000   00000010   2
00000000  00000000  00000000   00000011    3
-------------------------------------------
00000000  00000000  00000000   00000010    2

//操作|  遇1则1  任意整数|0  一定是本身
//任意整数|负数  一定是负数
00000000  00000000  00000000   00000010
00000000  00000000  00000000   00000011
--------------------------------------------
00000000  00000000  00000000   00000011    3

//操作^  相同则0不同则1  任意一个整数按位^
00000000  00000000  00000000   00000010
00000000  00000000  00000000   00000011
----------------------------------------------------
00000000  00000000  00000000   00000001     1

//操作~
//所有位按位取反
00000000  00000000  00000000   00000010
-----------------------------------------------
11111111  11111111  11111111   11111101   负数  补码
11111111  11111111  11111111   11111100   反码
10000000  00000000  00000000   00000011    源码   -3

*/

/*
按位异或的扩展结论(当一个整数按位异或上另一个整数两次结果还是本身)
*/

class WeiTest{
public static void main(String[] args) {
int a=2;
int b=5;
System.out.println(a^b^a^a);//7
System.out.println(a^b^a);//5
System.out.println(b^a^b);//2

}
}
/*
需求：两个数值交换
效率由高到低：按位异或(整数)  、 求和(一般是整数)  、 中间变量 (常用  任意数据、简单)

*/
class Wei{
int a=4;
int b=5;

//
System.out.println("a的值："+a+",b的值："+b);

1.中间变量

int temp =a;
a=b;
b=temp;
//
System.out.println("a的值:"+a+",b的值："+b);

2.按位异或

a=a^b;
b=a^b;//b=a^b^b=a
a=a^b;//a=a^b^a=b
//
System.out.println("a的值:"+a+",b的值："+b);

3.求和

a=a+b;
b=a-b;//b=a+b-b=a
a=a-b;//a=a+b-a=b
System.out.println("a的值:"+a+",b的值："+b);

效率由高到低：

按位异或   求和   中间变量

/*
位运算
>>(右移)、<<(左移)、>>>(无符号右移)
>>(右移)：当正数进行右移时，右移几位就在最左边位(最高位)补上几个0，当负数进行右移时，右移几位就在最高位补上几个1。
<<(左移)：无论正负数进行左移时，左移几位就在最低位补上几个0。
>>>(无符号右移)：无论正负数进行右移时，右移几位就在最高位补上几个0。

class WeiWei{

int a=12;
//操作>>  a/2`移动位数
System.out.println(a>>2);//3
//操作<<  a*2`移动位数
System.out.println(a<<2);//48
//操作>>>  结果一定是正数
System.out.println(a>>>2);//3

}
/*
00000000   00000000   00000000   00001100   int 12 补码

//操作>>  2
[00]00000000   00000000   00000000   000011(00)
-------------------------------------------------------
00000000   00000000   00000000   00000011   3

//操作<<  2
(00)000000   00000000   00000000   00001100[00]
--------------------------------------------------
00000000   00000000   00000000   00110000   48

//操作 >>>  2
[00]00000000   00000000   00000000   000011(00)
-------------------------------------------------------
00000000   00000000   00000000   00000011   3

*/

6.三目（元）运算符

（结果一定是一个值）
~a（一元） a+b（二元）
格式：布尔表达式？表达式值1：表达式值2
执行流程：先去计算出布尔表达式的值，如果是true返回表达式值1，如果是false返回表达式值2.
求两个整数的最大值

求？个整数最大值

class SanMuDemo{
public static void main(String[] args) {
//求两个整数的最大值;
/*int a=1;
int b=2;
//把三目返回值赋值给新变量
//两个表达式值的类型要小于等于接受值的类型
int max=a>b?a:b;
System.out.println(max);*/

//求三个整数最大值
/*int a=1;
int b=2;
int c=3;
//三目嵌套
System.out.println(a>b?(a>c?a:c):(b>c?b:c));

System.out.println(1>3-2);//false*/

//优先级  ()  ~  ++  --  !  *  /  %  +  -  <<  >>  >>> 关系  逻辑  &  |  ^  三元 赋值

}
}

7.运算符的优先级

（） ~ ++ – ! * / % + - << >> >>> 关系 逻辑 & | ^ 三元 赋值运算符