theboyaply
theboyaply
发布于 2020-01-03 / 871 阅读
0
0

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
& 逻辑与
&& 短路与
| 逻辑或
|| 短路或
! 逻辑非
^ 逻辑异或

aba&ba|ba&&ba||ba^b!a
truetruetruetruetruetruefalsefalse
truefalsefalsetruefalsetruetruefalse
falsetruefalsetruefalsetruetruetrue
falsefalsefalsefalsefalsefalsefalsetrue
// 逻辑与/逻辑或 和 短路与/短路或的区别
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

评论