**There are three kinds of shift operators in Java**

**<<: Left shift operator, num << 1, equals num multiplied by 2**

**>>: Right shift operator, NUM >> 1, equivalent num divided by 2**

**>>>: Unsigned Right shift, ignore sign bit, empty 0**

**1. Left shift operator**

The left shift operator << causes all bits of the specified value to shift to the left of the prescribed number of times.

1) Its general format is as follows:

Value << num

NUM Specifies the number of bits to shift the value to move.

Left-shift rule remembers only one point: Discard the highest bit, 0 the minimum bit

If the number of bits moved exceeds the maximum number of digits of the type, the compiler will model the number of bits moved. If you move 33 bits to the int type, you actually move only 332 = 1 bits.

2) Arithmetic rules

In binary form, all numbers are shifted to the left by the corresponding number of digits, the high position is removed (discarded), and the low vacancy is 0.

When the left-hand operand is of type int, the 31st bit of each 1-bit shift is moved out and discarded;

When the left-hand operand is a long type, the 63rd bit of each 1-bit move is moved out and discarded.

When the left-hand operand is byte and short, these types are automatically expanded to be of type int.

3) Mathematical significance

On the premise that the number is not overflow, for positive and negative numbers, the left one is the equivalent of multiplying by 2 by 1, and the left shift n is the equivalent of multiplying by 2 of the n-th square

4) Calculation process:

Example: 3 <<2 (3 for int type)

1) Convert 3 to binary number 0000 0000 0000 0000 0000 0000 0000 0011,

2) Move the digit high (left) to two 0, and the other numbers are shifted to the left by 2 bits,

3) Two vacancies in the low (right) 0. The resulting result is 0000 0000 0000 0000 0000 0000 0000 1100,

Conversion to decimal is 12.

The number of bits moved exceeds the maximum number of digits of the type,

If you move into a higher-order bit (31 or 63 bits), the value becomes negative. The following procedure illustrates this point:

Left shifting as a quick-to-multiply by 2.

public class Multbytwo {

public static void Main (String args[]) {

int i;

int num = 0xFFFFFFE;

for (i=0; i<4; i) {

num = num << 1;

SYSTEM.OUT.PRINTLN (num);

}

}

}

The output of the program is as follows:

536870908

1073741816

2147483632

-32

Note: n-bit binary, the highest bit is the sign bit, so the value range represented by -2^ (n-1)--2^ (n-1)-1, so the modulo is 2^ (n-1).

**2. Right shift operator**

Right-shift operator << causes all bits of the specified value to move to the right by the required number of times.

1) Its general format is as follows:

Value >> num

NUM Specifies the number of bits to shift the value to move.

The rule that moves right only remembers one point: the symbol bit is unchanged, the left side is the symbol bit

2) Operational rules:

In binary form, all numbers are shifted to the right by the corresponding number of digits, the lower position is removed (discarded), the high position of the empty fill sign bit, that is, positive 0, negative complement 1

These types are automatically expanded to int when the operands to the right move are of byte and short type.

For example, if the value to be removed is negative, each right shift is 1 on the left, and if the value to be moved is a positive number, each right shift is 0 on the left, which is called the sign bit extension (sign extension), which moves right

The symbol used to hold negative numbers during operation.

3) Mathematical significance

Move right one is equivalent to 2, and the right shift n is the equivalent of dividing by 2 of the n-th side.

4) Calculation process

One >>2 (11 for int type)

1) 11 in binary form: 0000 0000 0000 0000 0000 0000 0000 1011

2) Move the last two digits of the low position out, since the number is positive, so it is 0 at the high.

3) The final result is 0000 0000 0000 0000 0000 0000 0000 0010.

Conversion to decimal is 3.

>> 2 (35 for INT type)

35 conversion to binary: 0000 0000 0000 0000 0000 0000 0010 0011

Move the last two digits of the low: 0000 0000 0000 0000 0000 0000 0000 1000

Convert to decimal: 8

5) do not retain symbols when moving to the right

The values after the right shift are bitwise AND operation with 0x0f so that any sign bit extension can be discarded so that the resulting value can be used as the subscript for the definition array, resulting in the hexadecimal character represented by the corresponding array element.

For example

public class HexByte {

public static public void main (String args[]) {

Char hex[] = {

' 0 ', ' 1 ', ' 2 ', ' 3 ', ' 4 ', ' 5 ', ' 6 ', ' 7 ',

' 8 ', ' 9 ', ' A ', ' B ', ' C ', ' d ', ' e ', ' F '

};

byte B = (byte) 0xf1;

System.out.println ("b = 0x" hex[(b >> 4) & 0x0f] Hex[b & 0x0f]);}}

(b >> 4) & 0x0f operation Process:

The binary form of B is: 1111 0001

4-digit number is removed: 0000 1111

Bitwise AND operations: 0000 1111

to 10 in binary form: 15

B & 0x0f Operation process:

The binary form of B is: 1111 0001

The binary form of the 0x0f is: 0000 1111

Bitwise AND operations: 0000 0001

to 10 in binary form: 1

Therefore, the output of the program is as follows:

b = 0xf1

**3, unsigned Right shift**

Unsigned Right shift operator >>>

Its general format is as follows:

Value >>> num

NUM Specifies the number of bits to shift the value to move.

Unsigned right-shift rule remembers only one point: the symbol bit extension is ignored, and the top bit of the 0 complement

The unsigned Right shift operator >>> is only meaningful for 32-bit and 64-bit values

Shift Operator (JAVA)