I have always understood there to be two types of equality in Java,
.equals()
method to test that two objects implement an equivalence relation on non-null object references.==
operator to test that two primitive types or memory locations are equal.The following pages describe these language fundamentals in more detail.
What none of these links explicitly specify is what should happen if two null
object references are compared for value equality. The implicit assumption is that a NullPointerException
should be thrown but this is not what is done by the ObjectUtils.equals() method, which might be considered a best practice utility method.
What worries me is that Apache Commons seems to have effectively introduced a third measure of equality into Java by the back door and that the already confusing state of affairs might have been made greatly more complex. I call it a third measure of equality because it attempts to test for value equality and when that fails it falls back to testing for reference equality. The Apache Commons equality test has many similarities with the value equality and reference equality but is also distinctly different.
Am I right to be concerned and to want to avoid using the ObjectUtils.equals()
where ever possible?
Is there an argument for claiming that ObjectUtils.equals()
provides a useful union of the other two measures of equality?
There doesn't seem to be a consensus opinion on this question but I decided to mark Bozho's as correct because he best drew my attention to what I now see as the greatest problem with null-safe equals checks. We should all be writing fail-fast code that addresses the root cause of why two null objects are being compared for value equality rather than trying to sweep the problem under the carpet.
Here's the code of ObjectUtils.equals(..)
:
public static boolean equals(Object object1, Object object2) {
if (object1 == object2) {
return true;
}
if ((object1 == null) || (object2 == null)) {
return false;
}
return object1.equals(object2);
}
ObjecUtils docs state clearly that objects passed can be null.
Now on the matter whether true
should be returned if you compare two null
s. In my opinion - no, because:
NullPointerException
null
s to compare means that they got from somewhere instead of "real" objects, perhaps due to some problem. In that case comparing them alone is wrong - the program flow should have halted before that.equalOrBothNull()
- which differs from the equals
method in this utility in the null comparison.