Shift operation methods in java (<<, >>, >>>)

The following editor will bring you an article about java<<, >>, >>> shift operation methods. The editor thinks it is quite good, so I will share it with you now and give it as a reference for everyone. Let’s follow the editor to take a look.

<<, signed left shift, shifts the entire binary of the operand to the left by a specified number of digits, and fills the low bits with 0s.

int leftShift = 10;
System.out.println("十进制:" + leftShift + ", 二进制:" + Integer.toBinaryString(leftShift));
int newLeftShift = letfShift << 2;
System.out.println("左移2位后十进制:" + newLeftShift + ", 左移2位后二进制" + Integer.toBinaryString(newLeftShift)); //正整数x左移n位后的十进制结果，x = x * 2^n

The above are positive integers, and the operation results are as follows.

Next, let’s look at what happens when a negative number is left shifted by 2 bits. The result of the operation is as follows.

Why does the -10 binary have so many 1's? If you count carefully, there are exactly 32 bits. The first thing you need to understand is that Java negative numbers are stored in two's complement form (complement = complement + 1). The binary number of 10 is 1010, and its complement is 0101. Adding 1 is the complement 0110. So why are there so many extra 1's? This is because the int type occupies 8 bytes in Java, which is exactly 32 bits. The high bits of the original code of 10 are all 0, and the high bit of its complement code naturally becomes 1. Therefore, the entire operation is shifted left by 2 bits, and the low bits are filled with 0. The final operation result is x = (|x| + 2^n).

>>, signed right shift, shifts the entire binary number of the operand to the right by a specified number of digits, pads the high bits of integers with 0, and pads the high bits of negative numbers with 1 (keeping the sign of negative numbers unchanged).

int rightShift = 10;
System.out.println("十进制:" + rightShift + ", 二进制:" + Integer.toBinaryString(rightShift));
int newRightShift = rightShift >> 2;
System.out.println("右移2位后十进制:" + newRightShift + ", 右移2位后二进制" + Integer.toBinaryString(newRightShift));  //右移n位后的运算数x十进制结果，x = x / 2

The above are positive integers, and the operation results are as follows.

Next, let’s look at what happens when a negative number is shifted right by 2 bits. The result of the operation is as follows.

The basic principle of signed right shift of negative numbers is still the same as left shift. The difference is the calculation of the result, because this is a signed right shift, and the last one is always shifted to the right. The result will be -1. To sum up, if the operand is an even number, then its operation result is x = -(|x| / 2). If the operand is an odd number, then its operation result is x = -(|x| / 2) - 1.

>>>, unsigned right shift, no matter positive or negative, the high bits are filled with 0 (ignoring the sign bit)

Look at the positive numbers first, the positive numbers >>>The calculation results of unsigned right shift and >>signed right shift are the same

int rightShift = 10;
System.out.println("十进制:" + rightShift + ", 二进制:" + Integer.toBinaryString(rightShift));
int newRightShift = rightShift >>> 2;
System.out.println("右移2位后十进制:" + newRightShift + ", 右移2位后二进制" + Integer.toBinaryString(newRightShift));  //右移n位后的云算数x十进制结果，x = x / 2

The above are positive integers, and the operation results are as follows.

Next, let’s look at negative integers. The operation results are as follows.

Although the binary after unsigned shift and the binary after signed shift look the same, the results are quite different. Remember the signed right shift operation, in fact The above is an arithmetic operation that ignores signs, that is, the high bits are uniformly filled with 0.

The above is the detailed content of Shift operation methods in java (<<, >>, >>>). For more information, please follow other related articles on the PHP Chinese website!