• Post Reply Bookmark Topic Watch Topic
  • New Topic
programming forums Java Mobile Certification Databases Caching Books Engineering Micro Controllers OS Languages Paradigms IDEs Build Tools Frameworks Application Servers Open Source This Site Careers Other Pie Elite all forums
this forum made possible by our volunteer staff, including ...
Marshals:
  • Campbell Ritchie
  • Jeanne Boyarsky
  • Ron McLeod
  • Paul Clapham
  • Liutauras Vilda
Sheriffs:
  • paul wheaton
  • Rob Spoor
  • Devaka Cooray
Saloon Keepers:
  • Stephan van Hulst
  • Tim Holloway
  • Carey Brown
  • Frits Walraven
  • Tim Moores
Bartenders:
  • Mikalai Zaikin

shift operators

 
Ranch Hand
Posts: 261
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
class A
{
public static void main(String[] args)
{
test(1<<32, "1<<32");
test(1<<31, "1<<31");
test(1<<30, "1<<30");
test(1, "1");
test(0, "0");
test(-1, "-1");
}
public static void test(int i, String exp)
{
if ((i>>1)!=(i>>>1))
{
System.out.println(exp);
}
}
}




can any one help me out with the output of this program..and kindly explain me......
 
Greenhorn
Posts: 1
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
This program prints 1 << 31
-1

The range of int primitive is -2^31 to (2^31) - 1.

and so (1 << 31) does not fit in an int and results in a negative number.

where as due to the masking of bits,
when the value to be shifted is an int,
for the shift values of >=32, the actual size of the shift is the value of the right-hand operand masked by 31.
ie.the shift distance is always between 0 and 31.
if shift value is > 32 shift is value%32

So here, 1 << 32 = 1.
Ex:

16 << 35 => 16 << (35 % 32) => 16 << 3 = 128
16 << 32 => 16 << (32 % 32) => 16 << 0 = 16

16 >> 35 => 16 >> (35 % 32) = 2
16 >> 32 => 16 >> (32 % 32) = 16


similarly for longs
for the shift values of >=64, the actual size of the shift is the value of the right-hand operand masked by 63.
ie.the shift distance is always between 0 and 63.
if shift value is >= 64 shift is value%64

And this question tests one more concept,

in unsigned right shift operation,
if the left-hand operand is negative, the result is equivalent to the left-hand operand right-shifted by the number indicated by the right-hand operand plus two left-shifted by the inverted value of the right-hand operand.
So here -1 >>> 1 = (-1 >> 1) + (2 << ~1) = 2147483647.

and since -1 >> 1 = -1 they both are not equal.

Ex: -16 >>> 2 = (-16 >> 2 ) + ( 2 << ~2 )
---------------------------------------------
Swapna.
 
Ranch Hand
Posts: 78
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
Shift operators are not on the 1.5 exam in case you didn't know.
[ August 23, 2006: Message edited by: Andy Morris ]
 
Don't get me started about those stupid light bulbs.
reply
    Bookmark Topic Watch Topic
  • New Topic