# Left Shift Operator

Java allows bit shifting feature on integral type data. Shift operators are not used much in everyday programming task. But for interviews, questions of shift operators might be there. Before understanding what left shift does we first have to understand that how does integral data stored in Java. Note once again that only integer values can be left shifted in Java. Left shift operator is declared as ‘<<‘  (two less than characters) in java.

For integer number 10, it is stored in 4-bytes.

`00000000 00000000 00000000 00001010`

Now when you use left shift operator i.e 10 << 1 it will shift one bit to left. Now, number is stored like this,

```00000000 00000000 00000000 00001010 : 10
00000000 00000000 00000000 00010100 : 10 << 1 = 20
```

So, now value 10 becomes 20 (for binary 10100). If we want to shift by 2 bits like 10 << 2, then number will be 40 (for binary 101000),

```00000000 00000000 00000000 00001010 : 10
00000000 00000000 00000000 00101000 : 10 << 2 = 40
```

Similarly if we shift number 10 by 3 bits it will become 80. So here we can conclude that left shift works according to following formula,

number * 2 ^ shiftBitCount

Note here that left shift operator is signed operator and so it preserves the sign of the number during shift. For negative number say -10 the binary representation in 4 bytes will be 2’s complement of 10,

For number 10 we will do 1’s complement and add 1 to it,

``` 11111111 11111111 11111111 11110101 : 1's complement of 10
+00000000 00000000 00000000 00000001 : +1
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
11111111 11111111 11111111 11110110 : -10```

Let’s perform shift operation on -10 << 1,

`1111111 11111111 11111111 111101100 : -10 << 1 = -20`

Notice that while shifting we are padding zeros to the right and the shifted bits are lost in the space forever. Here the same formula applies and other than that the sign of the number is preserved by the left shifting operation.

Following Java program can elaborate the stated logic, kindly visit to my Number To Binary Hexa Octa String for basic introduction about Integer#toBinaryString.

```public class LeftShiftOperator {
public static void main(String[] args) {
int ten = 10;
System.out.println("Binary of " + ten + " : " + Integer.toBinaryString(ten));
ten = ten << 1;
System.out.println("Binary after left shift : " + Integer.toBinaryString(ten));
System.out.println("Shift Result of positive : " + ten);

int minusTen = -10;
System.out.println("Binary of minus " + minusTen + " : "+ Integer.toBinaryString(minusTen));
minusTen = minusTen << 1;
System.out.println("Binary after left shift : "+ Integer.toBinaryString(minusTen));
System.out.println("Shift Result of negative : " + minusTen);
}
}```

Above program will give us following output,

```Binary of 10 : 1010
Binary after left shift : 10100
Shift Result of positive : 20
Binary of minus -10 : 11111111111111111111111111110110
Binary after left shift : 11111111111111111111111111101100
Shift Result of negative : -20```

Left shift can only be performed on integer value we can do the shift on byte, short and char as well after casting them to int value. Because all the stated types are internally represented as an integer data.

Apparently, for shifting the auto-unboxing also takes place for wrapper class of int, Integer.

```Integer ten = new Integer(10);
ten = ten << 1;//It's valid due to auto-unboxing```

One more thing to note is that the left shifted bits are gone and never return back or can not be used any further for our integer value. So for large number if we shift them left the value may give you small negative value.

For example Integer.MAX_VALUE,

```01111111111111111111111111111111 : Integer.MAX_VALUE
1111111111111111111111111111110 : Integer.MAX_VALUE << 1 = -2```