Data Structures and Algorithms in Java[1].pdf - Fulvio Frisone

Hash Codes in Java
The generic Object class defined in a Java comes with a default hashCode()
method for mapping each object instance to an integer that is a "representation" of
that ob ject. Specifically, the hashCode() method returns a 32-bit integer of
type int. Un less specifically overridden, this method is inherited by every
object used in a Java program. We should be careful in using the default Object
version of hashCode(), however, as this could just be an integer interpretation
of the object's location in memory (as is the case in many Java implementations).
This type of hash code works poorly with character strings, for example, because
two different string ob jects in memory might actually be equal, in which case we
would like them to have the same hash code. Indeed, the Java String class
overrides the hashCode method of the Object class to be something more
appropriate for character strings. Like wise, if we intend to use certain objects as
keys in a map, then we should override the built-in hashCode() method for
these objects, replacing it with a mapping that assigns well-spread, consistent
integers to these types of objects.
Let us consider, then, several common data types and some example methods for
assigning hash codes to objects of these types.
Casting to an Integer
To begin, we note that, for any data type X that is represented using at most as
many bits as our integer hash codes, we can simply take as a hash code for X an
integer interpretation of its bits. Thus, for Java base types byte, short, int, and
char, we can achieve a good hash code simply by casting this type to int.
Likewise, for a variable x of base type float, we can convert x to an integer using
a call to Float.floatToIntBits(x), and then use this integer as x's hash
code.
Summing Components
For base types, such as long and double, whose bit representation is double that
of a hash code, the above scheme is not immediately applicable. Still, one
possible hash code, and indeed one that is used by many Java implementations, is
to simply cast a (long) integer representation of the type down to an integer the
size of a hash code. This hash code, of course, ignores half of the information
present in the original value, and if many of the keys in our map only differ in
these bits, then they will collide using this simple hash code. An alternative hash
code, then, which takes all the original bits into consideration, is to sum an integer
representation of the high-order bits with an integer representation of the loworder
bits. Such a hash code can be written in Java as follows:
525