什么是Java中一年和一个月元组的良好hashCode

Question

In Java, let's say I have a long list of Year and Month pairs. Like 2018:03 with a lot of duplicates.

Month will always be starting with 1.
Year will always be > Month, starting with 2010
if Month or Year == 0 [not_set], hashcode can return 0 (fine), I ignore them

I want to loop over this list and create a hash from those two values for every entry, to determine if I already have a specific combination.

Usually I would create an Object for such an entry, with two int members and override equals and hashcode, adding them all into a Set.

How should I implement the hashCode?

As far as I remember from effective java, I would write the something like:

@Override
public int hashCode() {
    int hash = year;
    hash = 31 * hash + month;
    return hash;
}

But I think, because month will always be lesser than year, in this case I am good with:

@Override
public int hashCode() {
    return year * month;
}

until the year 4020, there should not occur any collision.

Are there any more effective ways to achieve my goal, you can think of? Or is it too late already and my head is falling apart?

Answer 1

As long as it satisfies the general contract of hashCode , it should be a fine hash code implementation:

• Whenever it is invoked on the same object more than once during an execution of a Java application, the hashCode method must consistently return the same integer, provided no information used in equals comparisons on the object is modified. This integer need not remain consistent from one execution of an application to another execution of the same application.
• If two objects are equal according to the equals(Object) method, then calling the hashCode method on each of the two objects must produce the same integer result.
• It is not required that if two objects are unequal according to the equals(java.lang.Object) method, then calling the hashCode method on each of the two objects must produce distinct integer results. However, the programmer should be aware that producing distinct integer results for unequal objects may improve the performance of hash tables.

Another approach to implement the hashCode method would be to call Objects.hash :

return Objects.hash(year, month);

Answer 2

As you already mentioned Effective Java [1], here is the recipe to make a good hash function from the same book:

1. Declare an int variable named result, and initialize it to the hash code c for the first significant field in your object

2. For every remaining significant field f in your object, do the following:

   a. Compute an int hash code c for the field:

i. If the field is of a primitive type, compute Type.hashCode(f), where Type is the boxed primitive class corresponding to f's type.

ii. If the field is an object reference and this class's equals method compares the field by recursively invoking equals, recursively invoke hashCode on the field. If a more complex comparison is required, compute a “canonical representation” for this field and invoke hashCode on the canonical representation. If the value of the field is null, use 0 (or some other constant, but 0 is traditional).

iii. If the field is an array, treat it as if each significant element were a separate field. That is, compute a hash code for each significant element by applying these rules recursively, and combine the values per step 2.b. If the array has no significant elements, use a constant, preferably not 0. If all elements are significant, use Arrays.hashCode.

b. Combine the hash code c computed in step 2.a into result as follows:

result = 31 * result + c;

3. Return result.

Translating this recipe to yours:

@Override
public int hashCode() {
  int hash = Integer.hashCode(year);
  hash = 31 * hash + Integer.hashCode(month);
  return hash;
}

[1] Effective Java, Third Edition ( http://www.informit.com/store/effective-java-9780134685991 )

Answer 3

You can take a look at Java 8's java.time.YearMonth code (or the equivalent class in ThreenTen Backport , for Java <= 7). Both use:

public int hashCode() {
    return year ^ (month << 27);
}