Java运算符总结

算术运算符：+ - * / %
1.在算术运算符中值得注意的是：int/int得到的也是int
例：

int a = 1;
int b = 2;
System.out.println(a/b);//结果为0

要想得到小数，则两者之中至少有一个是float或者double类型
2. 0不能作为除数
例：

int a = 1;
int b = 0;
System.out.println(a/b);//编译不会报错
//运行结果
//Exception in thread "main" java.lang.ArithmeticException: / by zero

3.%取余/取模，在C语言中%的两个操作数只能是整数，而在Java中不仅可以是整数，也可以是double类型

System.out.println(3%2);//结果是1
System.out.println(-3%2);//结果是-1
System.out.println(-3.0%2);//结果是-1.0

4.+= -= *= /= %=

int a = 10;
int b = 20;
a += b;//相当于 a = a + b;

其他的同理
5.自增/自减运算符 ++ –

int a = 10;
int b = a++;
int c = ++a;
System.out.println(b);//运行结果10；
System.out.println(c);//运行结果12；

总结：
如果不取自增运算的表达式的返回值, 则前置自增（++a）和后置自增（a++）没有区别.
如果取表达式的返回值, 则前置自增的返回值是自增之后的值, 后置自增的返回值是自增之前的值.

关系运算符
== != < > <= >=

int a = 10;
int b = 20;
System.out.println(a == b);
System.out.println(a != b);
System.out.println(a < b);
System.out.println(a > b);
System.out.println(a <= b);
System.out.println(a >= b);

注意: 关系运算符的表达式返回值都是 boolean 类型.

逻辑运算符

&&
||
! ：

注意: 逻辑运算符的操作数(操作数往往是关系运算符的结果)和返回值都是 boolean .
&& 逻辑与
规则：两个操作数都是 true，结果才是 true，否则结果是 false

int a = 10;
int b = 20;
int c = 30;
System.out.println(a > b && b < c);//运行结果是false

|| 逻辑或
规则:两个操作数中有一个是 true,结果就是 true,有两个是 false，结果才是 false

int a = 10;
int b = 20;
int c = 30;
System.out.println(a > b || b < c);//运行结果是 true

！逻辑非
规则：操作数是 true,结果是 false,操作数是 false,结果是true

int a = 10;
int b = 20;
System.out.println(!(a > b));//运算结果是true

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

System.out.println(10 > 20 && 10 / 0 == 0);// 运算结果false 
System.out.println(10 < 20 || 10 / 0 == 0);// 运算结果true

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

结论:

1. 对于 && , 如果左侧表达式值为 false, 则表达式的整体的值一定是 false, 不会计算右侧表达式.
2. 对于 ||, 如果左侧表达式值为 true, 则表达式的整体的值一定是 true, 不会计算右侧表达式.
   逻辑与和逻辑或的陷阱

特殊的：
如果 表达式1 &（ | ）表达式2，表达式1和2都是boolean类型，那么仍然表示逻辑与或逻辑或，但是没有短路特性。
那么同样还是这个代码，将会出现异常（除数为0异常）

System.out.println(10 > 20 & 10 / 0 == 0);// 出现异常
System.out.println(10 < 20 | 10 / 0 == 0);// 出现异常

位运算符

& | ~ ^

顾名思义，位运算符就是对二进制位进行操作

&按位与：如果两个对应的二进制位都是1，按位与才是1，否则是0

int a = 10;//01010(省略高位27个0)
int b = 20;//10100(省略高位27个0)
System.out.println(a & b);//00000 结果是0

|按位或：如果两个对应的二进制位有一个是1，按位或结果为1，两个都是0，结果才是0

int a = 10;//01010(省略高位27个0)
int b = 20;//10100(省略高位27个0)
System.out.println(a | b);//11110 结果是30

~按位取反：0变为1，1变为0

int a = 10;// 	00000000 00000000 00000000 00001010
//按位取反补码 	11111111 11111111 11111111 11110101
//       原码  	10000000 00000000 00000000 00001011
System.out.println(~a);//结果为-11

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

int a = 1;//00000000 00000000 00000000 00000001
int b = 2;//00000000 00000000 00000000 00000010
System.out.println(a ^ b);//00000000 00000000 00000000 00000011  结果为3

移位运算

<< >> >>>

当然也是对二进制位进行操作

左移<<：左侧舍弃，右侧补0

int a = 10;//00000000 00000000 00000000 00001010
a <<= 2;//   00000000 00000000 00000000 00101000
System.out.println(a); //结果为40

右移>>: 右侧舍弃，左侧补原符号位

int a = -10;//补码：	11111111 11111111 11111111 11110110
a >>= 2;//右移两位	11111111 11111111 11111111 11111101
System.out.println(a);//结果为-3

无符号右移 >>>:右侧舍弃，左侧补0

int a = 10;//	00000000 00000000 00000000 00001010
a >>>= 2;//		00000000 00000000 00000000 00000010
System.out.println(a);//结果为2

总结：
左移一位相当于乘2，右移一位相当于除2；

条件运算符

表达式1 ？ 表达式2 ： 表达式3

当 表达式 1 的值为 true 时,以表达式 2 的值作为整个表达式的值; 当 表达式 1 的值为 false 时, 以表 达式 3 的值作为整个表达式的值

// 求两个整数的大值 
int a = 10; 
int b = 20; 
int max = a > b ? a : b;//表达式1为false，表达式3的值作为整个表达式的值
System.out.println(max);