java基础三(运算符介绍)

算术运算符

常见的算术运算符：
+ 加
- 减
* 乘
/ 除
% 取模
++ 自增1(前/后++)
- - 自减1(前/后- -)

int i = 12;

// 除法，结果为整数2
int j = i / 5;

// 使用double接收结果，此时结果为2
double d1 = i / 5;

// 此时结果为2.4
double d2 = i / 5.0;
double d3 = (double) i / 5;

// 取模，结果的正负取决于被模数的正负
int i1 = 12 % 5;// 2

int i2 = 12 % -5;// 2

int i3 = -12 % 5;// -2

int i4 = -12 % -5;// -2

// 前++ --：先自增/自减1，再做运算
// 后++ --：先做运算，再自增/自减1

赋值运算符

用自身作运算然后将结果赋值给自己
+= 加等于
-= 减等于
*= 乘等于
/= 除等于
%= 模等于

int i = 12;
// 相当于 i = i + 1
i += 1;

// 需要注意的是
short s = 10;
// 不能写为s = s + 1;，因为s + 1的结果为int类型，使用short类型的s接收是错误的。
// 但是可以使用+=，因为赋值运算符是在值本身作运算，不存在类型转换。同理其它几个赋值运算符也是这样
s += 1;

比较运算符

运算结果为true 或者 false
== 等于
<= 小于等于
= 大于等于
!= 不等于
< 大于
小于
instanceof 两个对象类型是否相等 A instanceof B

逻辑运算符

左右两端是boolean类型，运算结果为true 或者 false
& 逻辑与
&& 短路与
| 逻辑或
|| 短路或
! 逻辑非
^ 逻辑异或

// 逻辑与/逻辑或 和 短路与/短路或的区别
boolean a = true;
boolean b = false;
// 逻辑与：不管前面的a是true还是false，都会执行后面的b
if (a & b) {
   System.out.println(1);
}
// 短路与：如果前面的a是false，则不执行后面的b
if (a && b) {
   System.out.println(1);
}
// 个人总结：
// 逻辑与/逻辑或：将所有条件全部执行
// 短路与/短路或：当前面的条件满足/不满足，不执行后面的判断
// 建议使用短路与/或
// 下面给出一个明显的例子来证明短路与/短路或的好处
boolean b2 = true;
// 短路或：b2满足条件，不执行后面的1 / 0 == 1，不会报错 by zero
if (b2 || 1 / 0 == 1) {
   System.out.println(1);
}
// 逻辑或：即使b2满足条件，但还是会执行后面的的 1 / 0 == 1，因此会报错 by zero
if (b2 | 1 / 0 == 1) {
   System.out.println(1);
}

位运算符

左右两端是数字，运算结果为数字
<< 左移
>> 右移
>>> 无符号右移(没有无符号左移)
& 与运算
| 或运算
^ 异或运算
~ 取反

// 左移示例：
int i2 = 31 << 2;
//   0000 0000 0001 1111 = 31
// 0000 0000 0001 111100
//   00 0000 0001 111100 = 124
// 左移两位，舍去头两位，末尾补0

// 右移示例：
int i3 = 31 >> 2;
//   0000 0000 0001 1111 = 31
//   000000 0000 0001 1111
//   000000 0000 0001 11 = 7
int i4 = -31 >> 2;
// 1111 1111 1110 0001 = -31
// 111111 1111 1110 0001
// 111111 1111 1110 00
// 右移两位，头两位按符号补0或1，舍去尾两位

// 无符号右移
int i5 = 31 >>> 2;
//   0000 0000 0001 1111 = 31
//   000000 0000 0001 1111
//   000000 0000 0001 11 = 7
int i6 = -31 >>> 2;
// 1111 1111 1110 0001 = -31
// 001111 1111 1110 0001
// 001111 1111 1110 00
// (不管是正数还是负数，无符号右移时，头位一律补0)

// 与运算
int a = 12;
int b = 5;
int c = a & b;
// a: 0000 0000 0000 1100
// b: 0000 0000 0000 0110
// &: 0000 0000 0000 0100 = 4
// 可以把0看作false，1看作true，&运算时，只有同为1，结果为1

// 或运算
c = a | b;
// a: 0000 0000 0000 1100
// b: 0000 0000 0000 0110
// |: 0000 0000 0000 1110 = 13
// |运算时，只要有1，结果为1

// 异或运算
c = a ^ b;
// a: 0000 0000 0000 1100
// b: 0000 0000 0000 0110
// ^: 0000 0000 0000 1010 = 9
// ^运算时，一个为1，一个为0，结果为1

// 取反运算
c = ~a;
// a:  0000 0000 0000 1100
// ~a: 1111 1111 1111 0011
// ~运算时，所有数字全部取反

左移右移的实际位数

对于int类型的整数位移a>>b，系统先用b对32求余，得到的结果才是真正的位移数。
对于Long类型的整数位移a>>b，同上，不过是对64求余。
例如：
1 >> 32，实际位移数为：32%32=0
1L >> 32，实际位移数为：32%64=32

下面我们看个例子：

// 实际位移数 1
System.out.println(1 << 1);
// 实际位移数 1
System.out.println(1 << 33);

// 实际位移数 0
System.out.println(1 << 32);
// 实际位移数 32
System.out.println(1L << 32);

// 结果为：
2
2
1
4294967296