Java's clever method of displacement operation

Left shift operation: If x is of type byte, short, or char, then x is promoted to int;

2) If x is of type byte, short, char, or int, then n is reassigned (the process is: take the lower 5 of n's complement bits are then converted into decimal int values, which is equivalent to taking n modulo 32: n=n%32);

If x is long type, n is reassigned (the process is: take the lower 6 bits of n's complement and then Converting to a decimal int value is equivalent to taking n modulo 64: n=n%64);

(Because the int type is 4 bytes, that is, 32 bits, moving 32 bits will make no sense. For long, it is modulo 64)

3) Shift x to the left by n digits, and the entire expression produces a new value (the value of x remains unchanged);

// 左移: 向左移动，右边补0   
for (int i = 0;i < 8 ;i++)   
System.out.print( (1 << i) + " ");

output

80000000 c0000000 e0000000 f0000000 f8000000 fc000000 fe000000 ff000000

The above general rule is correct, but there is a limitation. For int type, the number of shifted digits does not exceed 32, and for long type, the number of shifted digits does not exceed 64. . Now perform the following test:

Java code

// 右移: 向右移动，如果符号位(int型为32位)为0，左边补0，符号位为1，左边补1   
// 符号位为1的右移   
for (int i = 0;i < 8 ;i++)   
System.out.print( Integer.toHexString(0x40000000 >> i) + " ");

0x80000000. After shifting 31 bits to the right, each bit becomes 1 (that is, -1). According to this idea, shifting 32 bits to the right is still -1, but right After shifting 32 bits, the result is the number itself.

By testing the left and right shift of int and long type data, we found that:

Java handles the shift operation "a > b", first perform b mod 32||64 operation, If a is of type int, take mod 32. If a is of type double, take mod 64, and then use the general shift operation rules mentioned above to shift.

At this point, you can understand why there is this statement

　// 符号位为1的右移   
// 最高4位为1000， 右移1位，变成1100也就是c,   
for (int i = 0;i < 8 ;i++)   
System.out.print( Integer.toHexString(0x80000000 >> i) + " ");

in the BitSet class, because Programmers who are familiar with jdk know that writing 1L

For more articles related to Java’s clever methods of displacement operation, please pay attention to the PHP Chinese website!