# Programming Tutorials

## The Left Shift

By: aathishankaran in Java Tutorials on 2007-02-06

The left shift operator, <<, shifts all of the bits in a value to the left a specified number of times. It has this general form:

`Value << num`

Here, num specifies the number of positions to left-shift the value in value. That is, the << moves all of the bits in the specified value to the left by the number of bit positions specified by num. For each shift left, the high-order bit is shifted out (and lost), and a zero is brought in on the right. This means that when a left shift is applied to an in operand, bits are lost once they are shifted past bit position 31. if the operand is a long, then bits are lost after bit position 63.

Java's automatic type promotions produce unexpected results when you are shifting byte and short values.

```//Left shifting a byte value.

class ByteShift {

public static void main (String args[]) {

byte a = 64, b;
int d;
d = a << 2;
b = (byte) (a<<2);

System.out.println("Original value of a: " + a);
System.out.println(" d and b: " + d + " " +b);
}
}```

The output generated by this program is shown here:

`Original value of a: 64d and b : 256 0`

Since a is promoted to int for the purposes of evaluation, left-shifting the value 64 (0100 0000) twice results in d containing the value 256 (1 0000 0000). However, the value in b contains 0 because after the shift, the low-order position (bit 31 or 63), the value will become negative. The following program illustrates this point:

```//Left Shifting as a quick way to multiply by 2.

class MultByTwo {

public static void main(String args[]) {

int count;
int num = 0Xffffffe;

for (count =0; count<4 ; count++) {
num = num << 1;
System.out.println(num);
}
}
}```

The program generates the following output:

`53687090810737418162147483632-32`

The starting value was carefully chosen so that after being shifted left 4 bit positions, it would produce -32. As you can see, when a 1 bit is shifted into bit 31, the number is interpreted as negative.