Why (boolean == true) type of comparisons should be avoided

Java has quite a big impact on its syntax/design by C/C++. Both the languages share quite a bit of syntax and ideas. But the designers of Java made the language strict and tightened it up significantly.

Lets focus our discussion on booleans. In C/C++ zero (0) is treated as false and anything except zero (1) is treated as true. This caused a lot of bugs that were not found at compile time, especially with assignment vs. comparison. Here is a code snippet for elaboration:

int i = number;
if ( i == 5 ) {
// do something
}

in C/C++ it is pretty easy to write the same code as:

int i = number;
if ( i = 5 ) { // note that there is an assignment involved here instead of a comparison
// do something
}

in C/C++ This will have the effect of assigning 5 to “i”, regardless of what “number” was equal to, the result will be non-zero, i.e. true, and after this code, “i” would equal 5.

In Java, we now have the “boolean” type which is either “true” or “false”. The parameter to the “if” statement has to be “boolean”, rather than an int as in C/C++. The code assigning 5 to i would not compile in Java. This is great, because we can now find a lot of bugs at compile time.

BUT When we assign one boolean to another, the returned value is that of the value we are assigning to. This means that the bug mentioned above is still possible if we are doing boolean comparisons! I have often seen code such as the following, even from experienced, otherwise good, Java programmers (I counted over 1000 occurrences in the project I was working on).

boolean b = false;
if ( b == true ) {
System.Out.println( “All hell doesn't broke lose.” );
}

But the same code can easily be written as:

boolean b = false;
if ( b = true ) {
System.Out.println( “All hell WILL broke lose.” );
}

This will not only compile fine in java but all hell will also break lose. So in my opinion its best to write the same piece of code as:

boolean b = false;
if ( b ) {
System.out.println( “All hell broke lose.” );
}

Also the Microsoft guys (very common with C/C++ programmers) came up with a little coding convention for their C/C++ code for these situations as:

int i = number;
if ( 5 == i ) {
// do something
}

This technique is safe as you cannot assign a variable or anything to a constant. My little secret when I used to interview people for C/C++ jobs I always gave them some type of code involving such comparisons and would keep an eye on how do they write their conditions to get an idea bout how much they have coded and how much pain they have suffered from having such bugs in the code. Anyways this technique is same as the if ( bool ) check.

It is pretty easy for a bug like this to slip in during maintenance. So we should keep an eye out for less careful future programmers who will be maintaining the code that we once wrote.