Java Magic Trick

One of the (many?) shortcomings of Java is, at least in my humble opinion, the lack of unsigned integers. This may seem a minor problem, but it becomes a real annoyance when you have to deal with bits and bytes.

Consider the right shift. As a good C/C++ programmer you know that right shifting of a signed integer is generally bad. Java defined two bit-wise right shift operators: >> and >>>. The first extends the sign, so that -2 >> 1 evaluates to -1 and -2 >>> 1 evaluates to (-1 & 0x7FFFFFFF), i.e. the left most bit that becomes vacant pending the shift is filled with a 0.

So far, so good. So you may be surprised from the result of the following code:

class Surprise
{
    public static void main( String[] args )
    {
        int result = -1 >>> 32;
        System.out.println( "surprise: "+result );
    }
}

I don’t want to spoil the result, so you may want to take some more time to think… Ready with your guess?

Well Suprise.java prints -1. That’s because the right hand side argument of the >>> operator is masked implicitly by 0x1F (i.e. taking values just between 0 and 31 included).

No warning is emitted during compilation, so you are pretty on your own – either you know or you don’t and trouble are ready to … byte you.

2 thoughts on “Java Magic Trick”

  1. object Surprise {
    def main( arg: Array[String] ) : Unit = {
    val result = -1 >>> 32
    println( s”Suprise: $result” )
    }
    }

    Scala is no better in this regard. (Hiding the kinks of the language under a library is an old trick to overcome the limitation of the language 🙂 )

    Beside, I’m using Scala on a daily basis.

Leave a Reply to max Cancel reply

This site uses Akismet to reduce spam. Learn how your comment data is processed.