CHAPTER 4 ■ OPERATORS
The hashCode and equals methods are closely related because they rely on the same premise. They
add together a set of values to create a value that can be used for comparison (an equals-to comparison
in the case of the equals method and equals-to, greater-than, and less-than comparisons in the case of
the hashCode method).■ Note When you implement the equals method, you must also implement the hashCode method. The
hashCode method determines where an object reference goes when put into a collection that uses a hashing
algorithm (such as the HashMap and HashTable classes). We address those two collections (and others) when we
get to data structures, later in the book. The goal of the hashCode method is to return a unique (or at least nearly
unique) identifier; that's why it starts with a prime number and multiplies by another prime number. Again, we get
to that in much greater detail.■ Caution When you implement both equals and hashCode (and you should implement both if you implement
one), you must make sure that they use the same fields. For example, if you use firstName and lastName in the
equals method, you must use firstName and LastName in the hashCode method. Otherwise, your comparisons
fail. Worse yet, you don't get exceptions; you get the wrong behavior and a hard-to-find bug.■ Caution The hashCode method must generate equal values for equal objects. Otherwise, comparisons that
should succeed fail, and you have another hard-to-find bug.Comparisons for Sorting
I include sorting in this topic because it's impossible to sort things without comparing them. Suppose
you want to sort a bunch of colorful rocks into the spectrum. To do so, you pick up each rock, compare it
to the other rocks, and use that information to decide where in the row of rocks each rock belongs.
Sorting comes to most people pretty readily, with little training. However, a computer has to be told
exactly how to do it. To that end, Java offers two mechanisms for creating comparisons that can be used
for sorting: implementing the compareTo method from java.util.Comparable and creating a class that
extends java.util.Comparator. We do both for our Person class. Classes don't have to implement both,
but many do. The String class offers a fine example of a class that implements both comparison
interfaces (and equals and hashCode), by the way.
To be able to compare objects with the goal of sorting them, we have to know more than whether
one object equals another. We also have to know whether one object is greater than or less than another
object. For our color-sorting example, we can assign an integer value to each color and then sort our
rocks by putting each one to the left of all the rocks its color value is greater than and to the right of all
the rocks its color value is less than. Rocks with the same color value make piles of rocks whenever that
happens (and that's comparable to what happens in Java when hash code values are identical).