My co-worker was overriding the equals() method. My response was, have you also overridden the hashCode() method? His response was because we won't use hash map or hash set, it shouldn't really matter if we override hashCode(). Is that correct?
Add a comment
|
6 Answers
Yes he is factually right - however, if you need to put your objects in a hash-based collection one day, you will have to add hashcodes everywhere, which can be annoying + on that day you might implement your hashcode incorrectly (i.e. not consistent with equals) because you miss some subtlety in the equals method...
Considering that most IDEs provide an auto equals/hashcode generation feature, I see little reason not to create both.
Another way to look at it is: when you override a method from a parent class, you should follow the contract defined by that parent class. In the case of Object, the javadoc of equals is pretty clear:
Note that it is generally necessary to override the hashCode method whenever this method is overridden, so as to maintain the general contract for the hashCode method, which states that equal objects must have equal hash codes.
So unless you have a real design reason not to override hashcode, the default decision should be to follow the parent class contract and override neither or both.
10 Comments
Marko Topolnik
+1 But on the other hand, if
equals is what the code depends on now, there's a very high chance of hashCode falling behind the changes to equals, once again ending up inconsistent with it. The best compromise, to my eyes, would be a simple return 1;---at least it's technically correct.
Louis Wasserman
My issue with
return 1; is that it seems likely to lead to silent, difficult-to-debug performance problems if you use HashSet later. Instead, I'd implement hashCode() as throw new UnsupportedOperationException(), which requires minimal effort, but makes it obvious when you come back and use a HashSet later that you didn't bother implementing hashCode() the first time.
assylias
@LouisWasserman Throwing an exception if you really don't want to implement hashcode is a very good idea indeed.
user1739658
Thank you very much everyone! assylias - what do you mean by "you will have to add hashcodes everywhere" in the first paragraph? Doesn't my co-worker just need to add the
hashCode() method back to that one class which he overrides equals()?assylias
If only one class is involved then yes you only have one method to add - I thought he wanted to apply it to many classes.
|
If you override equals(), do override hashCode() as well. Even if you don't use hashCode() now, you or somebody else might use it.
For more on this topic, check the excellent SO answer
Comments
It's a code smell. Findbugs for example will warn you if you override either hashCode or equals without overriding the other. You should override both so that they are consistent with one another (that is, a.equals(b) => a.hashCode() == b.hashCode()).
A little effort now may save a lot of headaches later.
3 Comments
bestsss
or.. having hashCode on a class not designed to be a key (being mutable for instance) can cause you a lot of more trouble later. Not having overridden hashCode will be caught immediately, having broken hashCode is much harder to trace.
sjr
if it's not supposed to be a key in a hash structure you can throw an exception inside hashcode... there is precedent for that for example in Google protocol buffers when the protocol message contains a MessageSet
bestsss
While a good solution if has the potent to break existing code (overall no one expects
hashCode() to throw an exception). I know code that uses hashCode to test for null (i.e. expecting NPE) [bogus getClass() would have been better] - so again it might be ok - but proposing it default is a bit risky.You must override hashCode in every class that overrides equals. Failure to do so will result in a violation of the general contract for Object.hashCode, which will prevent your class from functioning properly in conjunction with all hash-based collections, including HashMap, HashSet, and Hashtable.
Effective Java Item 9: Always override hashCode when you override equals.
If your class is a public class then you can not control how your classes will be used in future development. Without looking into source code (or through reflection) there is no way to know whether this class has overriden the hasCode method or not and the user will be surprised by the result if they use it in any hash based collections.
1 Comment
user1739658
That's true! I think my co-worker probably didn't think about releasing his code for other people to use and that he is probably going to be the main person working on the framework.
Actually assume that you create two different objects without overriding equals and hashCode methods. And then if you call equals method java calls hashCode method implicitly then checks the equality of hashcodes.
Overriding hashCode method is enough for checking equality of two objects. And it will be useful for future. You can use this class on collections.
Otherwise if you implement just equal method, it will solve just equality of two objects not more.
3 Comments
Marc Baumbach
Java doesn't implicitly call
hashCode for the default implementation of equals. It verifies two objects point to the same reference using ==. You can have hashCode return a random value on every call and the default implementation of equals will still work if you point to the same object.
ATrubka
Your statement about checking equality by hashCode() is actually incorrect. Same hash code doesn't guarantee you equality.
emin
Yes Mark you are right it checks references. ATrubka,in my answer I especially specified that default implementation of Object class will be used for my example. The other possibilities not specified in my answer.
General:
only override those methods which you want to use in your own way and also those methods which are affected by this overriding.
Specific to your Ques:
From java docs,
Note that it is generally necessary to override the hashCode method whenever equals() method is overridden, so as to maintain the general contract for the hashCode method, which states that equal objects must have equal hash codes.
