Combining Java hashcodes into a "master" hashcode

java hash

2022-09-01 23:39:24

I have a vector class with hashCode() implemented. It wasn't written by me, but uses 2 prime numbers by which to multiply the 2 vector components before XORing them. Here it is:

    /*class Vector2f*/
...
    public int hashCode()
    {
        return 997 * ((int)x) ^ 991 * ((int)y); //large primes! 
    }

...As this is from an established Java library, I know that it works just fine.

Then I have a Boundary class, which holds 2 vectors, "start" and "end" (representing the endpoints of a line). The values of these 2 vectors are what characterize the boundary.

    /*class Boundary*/
...
    public int hashCode()
    {
        return 1013 * (start.hashCode()) ^ 1009 * (end.hashCode());
    }

Here I have attempted to create a good hashCode() for the unique 2-tuple of vectors (start & end) constituting this boundary. My question: Is this hashCode() implementation going to work?

(Note that I have used 2 different prime numbers in the latter hashCode() implementation; I don't know if this is necessary but better to be safe than sorry when trying to avoid common factors, I guess -- since I presume this is why primes are popular for hashing functions.)

答案 1

That's the normal practice. It looks pretty reasonable to me. If you're using Eclipse, you should find that it can generate and for you—just check the Source menu. It will do the same thing—enumerate your fields and create an method that checks all of them, then choose n prime numbers and do what you've done to create a method.equalshashCodeequalshashCode

答案 2

The reason for using prime numbers (they don't necessarily have to be "large" prime numbers) is indeed to avoid common factors.

Hash codes are used by hash-based collection classes such as and . They work best if the hash codes of objects in the map are as dissimilar as possible (they have to do more work to distinguish objects if the hash code of those objects is the same).HashSetHashMap

Multiplying the hash codes of the parts that you use to make a combined hash code with primes ensures that the parts will not have common factors, so there's less chance of collisions (with regard to the hash codes of different parts overlapping each other).