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
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.
Andrea says:
Get back to Scala 😛
https://github.com/scodec/scodec
max says:
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.