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: 64
d 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:

536870908
1073741816
2147483632
-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.