How do we decide on the best implementation of hashCode()
method for a collection (assuming that equals method has been overridden correctly) ?
“As much as is reasonably practical, the hashCode() method defined by class Object does return distinct integers for distinct objects. (This is typically implemented by converting the internal address of the object into an integer, but this implementation technique is not required by the JavaTM programming language.)”
equals , must have the same hashCode. hashCode values should be spread as evenly as possible over all ints. hashCode should be relatively quick to compute. hashCode must be deterministic (not random).
To get this hashcode value for an object, we can use the hashcode() method in Java. It is the means hashcode() method that returns the integer hashcode value of the given object. Since this method is defined in the Object class, hence it is inherited by user-defined classes also.
The best implementation? That is a hard question because it depends on the usage pattern.
A for nearly all cases reasonable good implementation was proposed in Josh Bloch's Effective Java in Item 8 (second edition). The best thing is to look it up there because the author explains there why the approach is good.
Create a int result
and assign a non-zero value.
For every field f
tested in the equals()
method, calculate a hash code c
by:
boolean
: calculate (f ? 0 : 1)
;byte
, char
, short
or int
: calculate (int)f
;long
: calculate (int)(f ^ (f >>> 32))
;float
: calculate Float.floatToIntBits(f)
;double
: calculate Double.doubleToLongBits(f)
and handle the return value like every long value;hashCode()
method or 0 if f == null
;Combine the hash value c
with result
:
result = 37 * result + c
Return result
This should result in a proper distribution of hash values for most use situations.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With