[英]How does bitshifting work in Java?
I have this statement: 我有这句话:
Assume the bit value of byte
x
is 00101011. what is the result ofx>>2
? 假设字节x
的位值为00101011。xx>>2
的结果是什么?
How can I program it and can someone explain me what is doing? 我该如何编程,有人可以解释我在做什么?
Firstly, you can not shift a byte
in java, you can only shift an int
or a long
. 首先,您不能在java中移位byte
,只能移位int
或long
。 So the byte
will undergo promotion first, eg 因此,该byte
将首先进行升级,例如
00101011
-> 00000000000000000000000000101011
00101011
> 00000000000000000000000000101011
or 要么
11010100
-> 11111111111111111111111111010100
11010100
> 11111111111111111111111111010100
Now, x >> N
means (if you view it as a string of binary digits): 现在, x >> N
表示(如果您将其视为一串二进制数字):
00000000000000000000000000101011 >> 2
-> 00000000000000000000000000001010
00000000000000000000000000101011 >> 2
> 00000000000000000000000000001010
11111111111111111111111111010100 >> 2
-> 11111111111111111111111111110101
11111111111111111111111111010100 >> 2
> 11111111111111111111111111110101
The binary 32 bits for 00101011
is 00101011
的二进制32位是
00000000 00000000 00000000 00101011
, and the result is: 00000000 00000000 00000000 00101011
,结果是:
00000000 00000000 00000000 00101011 >> 2(times)
\\ \\
00000000 00000000 00000000 00001010
Shifts the bits of 43 to right by distance 2; 将43位右移距离2; fills with highest(sign) bit on the left side. 用左侧的最高(符号)位填充。
Result is 00001010 with decimal value 10. 结果为00001010,十进制值为10。
00001010
8+2 = 10
When you shift right 2 bits you drop the 2 least significant bits. 当您右移2位时,将丢弃2个最低有效位。 So: 所以:
x = 00101011
x >> 2
// now (notice the 2 new 0's on the left of the byte)
x = 00001010
This is essentially the same thing as dividing an int by 2, 2 times. 这与将整数除以2、2倍本质上是相同的。
In Java 在Java中
byte b = (byte) 16;
b = b >> 2;
// prints 4
System.out.println(b);
These examples cover the three types of shifts applied to both a positive and a negative number: 这些示例涵盖了应用于正数和负数的三种类型的移位:
// Signed left shift on 626348975
00100101010101010101001110101111 is 626348975
01001010101010101010011101011110 is 1252697950 after << 1
10010101010101010100111010111100 is -1789571396 after << 2
00101010101010101001110101111000 is 715824504 after << 3
// Signed left shift on -552270512
11011111000101010000010101010000 is -552270512
10111110001010100000101010100000 is -1104541024 after << 1
01111100010101000001010101000000 is 2085885248 after << 2
11111000101010000010101010000000 is -123196800 after << 3
// Signed right shift on 626348975
00100101010101010101001110101111 is 626348975
00010010101010101010100111010111 is 313174487 after >> 1
00001001010101010101010011101011 is 156587243 after >> 2
00000100101010101010101001110101 is 78293621 after >> 3
// Signed right shift on -552270512
11011111000101010000010101010000 is -552270512
11101111100010101000001010101000 is -276135256 after >> 1
11110111110001010100000101010100 is -138067628 after >> 2
11111011111000101010000010101010 is -69033814 after >> 3
// Unsigned right shift on 626348975
00100101010101010101001110101111 is 626348975
00010010101010101010100111010111 is 313174487 after >>> 1
00001001010101010101010011101011 is 156587243 after >>> 2
00000100101010101010101001110101 is 78293621 after >>> 3
// Unsigned right shift on -552270512
11011111000101010000010101010000 is -552270512
01101111100010101000001010101000 is 1871348392 after >>> 1
00110111110001010100000101010100 is 935674196 after >>> 2
00011011111000101010000010101010 is 467837098 after >>> 3
>>
is the Arithmetic Right Shift operator. >>
是算术右移运算符。 All of the bits in the first operand are shifted the number of places indicated by the second operand. 第一个操作数中的所有位都移位了第二个操作数指示的位数。 The leftmost bits in the result are set to the same value as the leftmost bit in the original number. 结果中最左边的位设置为与原始编号最左边的位相同的值。 (This is so that negative numbers remain negative.) (这样负数就保持负数。)
Here's your specific case: 这是您的具体情况:
00101011
001010 <-- Shifted twice to the right (rightmost bits dropped)
00001010 <-- Leftmost bits filled with 0s (to match leftmost bit in original number)
public class Shift {
public static void main(String[] args) {
Byte b = Byte.parseByte("00101011",2);
System.out.println(b);
byte val = b.byteValue();
Byte shifted = new Byte((byte) (val >> 2));
System.out.println(shifted);
// often overloked are the methods of Integer
int i = Integer.parseInt("00101011",2);
System.out.println( Integer.toBinaryString(i));
i >>= 2;
System.out.println( Integer.toBinaryString(i));
}
}
Output: 输出:
43
10
101011
1010
You can't write binary literals like 00101011
in Java so you can write it in hexadecimal instead: 您不能用Java编写像00101011
这样的二进制文字,因此可以用十六进制来编写它:
byte x = 0x2b;
To calculate the result of x >> 2
you can then just write exactly that and print the result. 要计算x >> 2
的结果,您可以准确地写出并打印结果。
System.out.println(x >> 2);
byte x = 51; //00101011
byte y = (byte) (x >> 2); //00001010 aka Base(10) 10
You can use eg this API if you would like to see bitString presentation of your numbers. 如果您想查看数字的bitString表示形式,则可以使用此API。 Uncommons Math 罕见的数学
Example (in jruby) 示例(在jruby中)
bitString = org.uncommons.maths.binary.BitString.new(java.math.BigInteger.new("12").toString(2))
bitString.setBit(1, true)
bitString.toNumber => 14
edit : Changed api link and add a little example 编辑 :更改了api链接,并添加了一个小例子
00101011 = 43 in decimal 00101011 =十进制43
class test {
public static void main(String[] args){
int a= 43;
String b= Integer.toBinaryString(a >> 2);
System.out.println(b);
}
}
Output: 输出:
101011 becomes 1010 101011变成1010
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.