Java 移位运算、符号位扩展

时间:2022-03-31 13:08:30

类型取值范围

short 是1字节,即8位。而且 Java 中只有有符号数,所以最大值 0111,1111=2^7-1. 同时计算机中以补码形式存负数,所以可以多表示一个数,则最小值 1000,0000=-2^7=-128. 【因为原码中有 +0 -0,所以反码也一样】

Java 移位运算、符号位扩展

图源

那么如果我传入的 byte 超过最大值 127 呢?

byte a = (byte)234;
System.out.println(a); // 输出-22

234原码: 11101010,因为 byte 高位为符号位,所以会被当作 [1,110 1010] 也就是负数,即被当作补码传入。

我们转回原码:[1,110 1001] -- [1,001 0110] 原码表示 -22.

同理,可以再看:

byte a = (byte)257;  // 因为上溢了,只能(byte)强转
System.out.println(a); // 输出 1

257 原码=补码=[10000 0001] 已经9位了,所以截取后8位[0,000 0001] 即结果为 1

byte 转 int

上溢情况

上文已经出现了234 byte 会变成 -22 byte. 只要超过最大值 2^7-1=127 就会出现溢出。

解决溢出,就只能用能表示更大数的 int。转的过程需要配合使用 & 0xff,与 0xff 十六进制 1111 1111。

初识很奇怪,任何数同 0xff 与不是本身吗?

原因是,0xff 默认是整形,而整形 int 是4字节,即32位。那么同 byte 相与的时候,byte 会自动补24个0【因为是正数,负数则补1】

00000000 00000000 00000000 11101010  (byte)234
00000000 00000000 00000000 11111111 &
--------------------------------------
00000000 00000000 00000000 11101010 int 的234

这样最高位就变成了 0,即表示正数 234.

我们可以检验一下负数补1的情况:

byte c=-127;
int d = c & 0xff;
System.out.println(c); // -127
System.out.println(d); // 129
11111111 11111111 11111111 100000001 // 后8位表示 负数byte -127。负数补 1
00000000 00000000 00000000 11111111 & // 0xff
-------------------------------------
00000000 00000000 00000000 100000001 // 变成正数 129

下面例子为 234 < 256,应该不难理解了

byte b = (byte) 234;  // 大于127溢出,8位最大2^8-1=256
System.out.println(b); // -22
int a = b & 0xff;
System.out.println(a); // 234
int c = b;
System.out.println(a); // -22

无溢出转 int

直接赋值,也是正常的

byte c=(byte)-1;
int e = c;
int d = c & 0xffffffff;
System.out.println(c); // -1
System.out.println(e); // -1
System.out.println(d); // -1

-1补码 [1,111 1111]

①扩展32位则,高位补符号位[11111111 11111111 11111111 1,111 1111]

②0xffffffff 4*8=32位

那么①②相与还是①,而①变回原码[1,00...001] 就是-1。

这也验证了,高位补符号位的事

总结:如果 byte 没有出现上溢,即正数负数都是合理的,那么 byte 转 int 直接赋值即可。

出现上溢且小于255(最多8位,否则就截断了)就使用 & 0xff 转 int

下溢情况(截断情况)

byte最小能表示-128,输入-129.就会截断.

-129原码[1,1000 0001] 占9位 > byte 8位。

-129补码[1,0111 1111]

截断后:

-129在byte[0,111 1111] 恰好是127. 所以不管是 与上 0xff 或者补与,结果输出127正数

byte c=(byte)-129;
int d = c & 0xff;
System.out.println(c); // 127
System.out.println(d); // 127

>> 右移运算符

将数字以二进制表示,整体右移,高位补符号位.

我们先看 byte 的实例。byte 为8为,最高位符号位

byte a = -1;
byte b = (byte) (a >> 1);
System.out.println(b); // 输出 -1

过程:

-1 -->源码 [1,000 0001] -->反码[1,111 1110] -->补码[1,111 1111] -->右移高位补符号位[11,111 111] 即为补码 [1,111 111] 这个不就是 -1 的补码形式嘛。所以结果 -1

PS: 不要对源码直接右移补符号位, 有些情况是“看上去可以的” 如 -12

下面的例子也一样,右移高位补符号位

byte a = -4;
byte b = (byte) (a >> 3);
System.out.println(b); // 输出 -1

因为在计算机中,正数存储的补码和原码一致,所以比较简单,就不举例了。

<< 左移运算符

将数字以二进制表示,整体右移,低位补0.

byte a = -125;
byte b = (byte) (a << 2);
System.out.println(b); // 输出12

-125原码:[1,111 1101] 反码:[1,000 0010] 补码:[1,000 0011]

然后左移两位 1,0 (出界)[00 001100],末尾补00,所以补码[0,000 1100] 正好是正数 12

>>> 无符号右移

既然是无符号了,即高位全补0,不再是补符号位,不同于 >>

这里有个小坑点,先说结论,就是对于 short byte 的不足32位的,都先高位补符号位,变成32位,随后右移,高位补0

如下例子:

byte a = -1;
byte b = (byte)(a>>>6);
System.out.println(b); // -1

没有输出想象的正数。就是因为short byte 都是针对 int 的低位截断,是通过 int 移位再截断

过程:

-1补码:[1,111 1111]
变成32位,高位补符号位,[11111111 11111111 11111111 1,111 1111]
无符号移动[000000 11111111 11111111 11111111 1,1] ③式
截断[1,1111 1111]——补码
最终变成原码还是 -1

我们可以验证一下:

byte a = -1;
int b = (a>>>6);
System.out.println(b); // 67108863
System.out.println(Integer.toBinaryString(b)); // [00000011 11111111 11111111 11111111] 和③式一致

以上移位的目的是为了方便计算机高效的计算,移动一位,正好是 *2 /2,扩大倍数

参考

https://*.com/questions/16763917/what-is-the-purpose-of-the-unsigned-right-shift-operator-in-java

https://www.cnblogs.com/think-in-java/p/5527389.html

https://cloud.tencent.com/developer/article/1338265

https://blog.csdn.net/ruanrunxue/article/details/103655841