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);

<< is the left shift symbol, and the column x

// 左移: 向左移动，右边补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 << (bitIndex % 64) is redundant for jdk.

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