The Left Shift

By: aathishankaran  

The left shift

             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;






The program generates the following output:







     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.


Archived Comments

Most Viewed Articles (in Java )

Latest Articles (in Java)