Java 7 - Dot Equals

Comparing two objects is one of the most common tasks developers do. Yet its one where Java feels rather, well verbose. I just find those .equals() seem to be clutter rather than clarity. So what can we do?

Groovy equals

One of the key changes that Groovy made compared to Java was the alteration of the meaning of the == operator. Here's the change that was made:

  // Java
  if (person1.equals(person2)) { ... }

  // Groovy
  if (person1 == person2) { ... }

For those that don't know Groovy, these two extracts of code are identical at the bytecode level. Groovy simply makes the == operator call the equals() method. What about the not equal example:

  // Java
  if (!person1.equals(person2)) { ... }
  // or
  if (person1.equals(person2) == false) { ... }

  // Groovy
  if (person1 != person2) { ... }

And when you actually want to check for equality?

  // Java
  if (person1 == person2) { ... }

  // Groovy
  if (person1 === person2) { ... }

So, Groovy uses two equals symbols, ==, to mean equals() and three equals symbols, ===, to mean equality.

Personally, I find the Groovy code using == to mean equals() to be a lot clearer. But, clearly Java cannot be improved in the same way. Redefining the meaning of the == operator would break lots and lots of existing code and be very confusing.

Dot equals

I do believe there is a possible alternative that fits Java-Style. The concept is to add a new operator to the language that maps to the equals() method:

  if (person1 .= person2) { ... }

So, dot-equals is a new operator in the language, consisting of a dot immediately followed by an equals symbol. This compiles to the following standard Java code:

  if (person1.equals(person2)) { ... }

The advantage of the dot-equals operator is that it retains the visibility of the dot. And the dot allows existing Java developers to link the operator to the actual method call going on in the background. The dot also provides a hint that a NPE could occur at that point.

However, it is also possible to eliminate NPE completely from the dot-equals operator. To achieve this, the code would compile to something like this instead:

  if (System.nullSafeEquals(person1, person2)) { ... }

Given how many NPEs we suffer from, this seems like a Good Thing. But it does make the meaning of the dot-equals operator more complex. Opinions welcome on whether to eliminate NPEs or compile straight to equals().

Finally, what about the not equals concept? This is where things are not so pretty:

  // option A
  if (!person1 .= person2) { ... }

  // option B
  if (person1 !.= person2) { ... }

  // option C
  if (person1 .!= person2) { ... }

I have to say that option A misses the point for me - its too easy to lose the ! symbol. Neither option B or C are beautiful, but they are viable. If you've any other suggestions there I'd love to hear.

Summary

So, this is a proposal for a .= operator:

  // existing
  if (person1.getSurname().equals(person2.getSurname())) { ... }

  // proposed
  if (person1.getSurname() .= person2.getSurname()) { ... }

So, what am I missing? Do you love it or hate it? Is it clear and readable, or really obsure? Feedback welcomed of course.