Java Left and Right Shift Operator

We’ll cover the following

  • Java Left Shift Operator
  • Java Right Shift Operator

Java Left Shift Operator

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.

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 discard, and a zero is brought in on the right.

This means that when a left shift is applied to an int 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.

Java byte and short values are promoted to int when an expression is evaluated.

The result of such an expression is also an int.

The outcome of a left shift on a byte or short value will be an int, and the bits shifted left will not be lost until they shift past bit position 31.

A negative byte or short value will be sign-extended when it is promoted to int.

Thus, the high-order bits will be filled with 1’s.

To perform a left shift on a byte or short implies that you must discard the high-order bytes of the int result.

For example, if you left-shift a byte value, that value will first be promoted to int and then shifted.

The easiest way to do this is to simply cast the result back into a byte. The following program demonstrates this concept:


// Left shifting a byte value.
public class Leftshift {
  public static void main(String args[]) {
    byte a = 64, b;
    int i;

    i = a << 2;
    b = (byte) (a << 2);

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

The output generated by this program is shown here:

Since a is promoted to int for the purposes of evaluation, left-shifting the value 64 (0100 0000) twice results in i containing the value 256 (1 0000 0000).

However, the value in b contains 0 because after the shift, the low-order byte is now zero.

Its only 1 bit has been shifted out.

Since each left shift has the effect of doubling the original value, programmers frequently use this fact as an efficient alternative to multiplying by 2.

But you need to watch out. If you shift a 1 bit into the high-order position (bit 31 or 63), the value will become negative.

The following program illustrates this point:


public class Leftshift {
  public static void main(String args[]) {
    // Left shifting as a quick way to multiply by 2.

    int i;
    int num = 0xFFFFFFE;

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

  }
}

The starting value was 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.

Java Right Shift Operator

The right shift operator, >>, shifts all of the bits in a value to the right a specified number of times.

Its general form is shown here:

value >> num

Here, num specifies the number of positions to right-shift the value in value.

The >> moves all of the bits in the specified value to the right the number of bit positions specified by num.

The following code fragment shifts the value 32 to the right by two positions, resulting in a being set to 8:

int a = 32;
a = a >> 2; // a now contains 8

When a value has bits that are “shifted off,” those bits are lost.

For example, the next code fragment shifts the value 35 to the right two positions, which causes the two low-order bits to be lost, resulting again in a being set to 8:

int a = 35;
a = a >> 2; // a contains 8

Each time you shift a value to the right, it divides that value by two-and discards any remainder.

In some cases, you can take advantage of this for high-performance integer division by 2.

When you are shifting right, the top (leftmost) bits exposed by the right shift are filled in with the previous contents of the top bit.

This is called sign extension and serves to preserve the sign of negative numbers when you shift them right.

For example, -8 >> 1 is -4, which, in binary, is

11111000    -8
>> 1
11111100    -4

It is interesting to note that if you shift -1 right, the result always remains -1, since sign extension keeps bringing in more ones in the high-order bits.

Sometimes we do not need sign-extend values when you are shifting them to the right.

For example, the following program converts a byte value to its hexadecimal string representation.

Notice that the shifted value is masked by ANDing it with 0x0f to discard any sign-extended bits so that the value can be used as an index into the array of hexadecimal characters.

// Masking sign extension.
public class Maskingsign {
    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]);
    }
}

Here is the output of this program:

That’s it!
You have successfully completed the post. Do Share : )

Peace Out!

Also Read – Java Bitwise Operators


Check Out Deals on -> Amazon , Flipkart , Myntra , Adidas , Apple TV , Boat , Canva , Beardo , Coursera , Cleartrip , Fiverr , MamaEarth , Swiggy, KFC


2 Comments

Leave a Reply

Your email address will not be published.