When comparing a string variable to a string literal with .equals(), is there a standard practice for the order of items? [closed]

Question

There are benefits to each and I understand the differences, but what is considered best / standard practice? And why?

For example :

"myString".equals(myStringVar)

• Avoids a potential NPE and does not require a null check. (Good thing?)
• Cleaner to read since a null check is not required.
• If null is not an expected value, your program could be breaking without being any the wiser.

However

myStringVar.equals("myString")

• Requires a null check if null is an expected value. (Good thing?)
• Can clutter up compound conditionals with null checks.
• Allows for NPE to let us know if something has broken.

Which variation is considered the standard to use for Java, and why?

Answer 1

I suspect that this originates from a safety precaution used when programming in older C (or C++). In C, you could accidentally assign a value when you mean to test equality:

if (x = 3)

This condition will always be true, since it's assignment x a value of 3, not testing that x is equal to 3. To avoid this subtle bugs, developers started reversing the condition:

if (3 = x)

This contains the same "bug", but will generate a compiler error, so it's safer.

More modern languages don't have this problem, and they can easily warn you when you try to do these sorts of things. As such, it's no pretty much pure preference, so pick one, and use it consistently.

Answer 2

• Standard and good practice would vary with a culture of an organisation you are working for

• Our standard in .NET is myStringVar == "myString" simply because we have agreed on it, i.e. we believe it to be clean and concsice

Note: This does not apply to Java due to == comparing the references instead of the objects themselves. In Java you should be using myStringVar.equals("myString").

Answer 3

I think you're right in that it depends on the nullness semantics of the variable. If you don't expect it to be null and don't have to check for and handle it then the first form is cleaner.

That said, rather than embed the string literal, a better option would probably be this:

private final String MY_STRING = "myString";
if(MY_STRING).equals(myStringVar);

Especially if there is potential for using the string in more place than one.