# What is a good 64bit hash function in Java for textual strings?

Why don’t you use a `long` variant of the default `String.hashCode()` (where some really smart guys certainly put effort into making it efficient – not mentioning the thousands of developer eyes that already looked at this code)?

``````// adapted from String.hashCode()
public static long hash(String string) {
long h = 1125899906842597L; // prime
int len = string.length();

for (int i = 0; i < len; i++) {
h = 31*h + string.charAt(i);
}
return h;
}
``````

If you’re looking for even more bits, you could probably use a `BigInteger`
Edit:

As I mentioned in a comment to the answer of @brianegge, there are not much usecases for hashes with more than 32 bits and most likely not a single one for hashes with more than 64 bits:

I could imagine a huge hashtable distributed across dozens of servers, maybe storing tens of billions of mappings. For such a scenario, @brianegge still has a valid point here: 32 bit allow for 2^32 (ca. 4.3 billion) different hash keys. Assuming a strong algorithm, you should still have quite few collisions. With 64 bit (18,446,744,073 billion different keys) your certainly save, regardless of whatever crazy scenario you need it for. Thinking of usecases for 128 bit keys (340,282,366,920,938,463,463,374,607,431 billion possible keys) is pretty much impossible though.

To combine the hash for several fields, simply do an XOR multiply one with a prime and add them:

``````long hash = MyHash.hash(string1) * 31 + MyHash.hash(string2);
``````

The small prime is in there to avoid equal hash code for switched values, i.e. {‘foo’,’bar’} and {‘bar’,’foo’} aren’t equal and should have a different hash code. XOR is bad as it returns 0 if both values are equal. Therefore, {‘foo’,’foo’} and {‘bar’,’bar’} would have the same hash code.