Class Hashing
 java.lang.Object

 com.google.common.hash.Hashing

public final class Hashing extends Object
Static methods to obtainHashFunction
instances, and other static hashingrelated utilities.A comparison of the various hash functions can be found here.
 Since:
 11.0
 Author:
 Kevin Bourrillion, Dimitris Andreou, Kurt Alfred Kluever


Method Summary
All Methods Static Methods Concrete Methods Deprecated Methods Modifier and Type Method Description static HashFunction
adler32()
Returns a hash function implementing the Adler32 checksum algorithm (32 hash bits).static HashCode
combineOrdered(Iterable<HashCode> hashCodes)
Returns a hash code, having the same bit length as each of the input hash codes, that combines the information of these hash codes in an ordered fashion.static HashCode
combineUnordered(Iterable<HashCode> hashCodes)
Returns a hash code, having the same bit length as each of the input hash codes, that combines the information of these hash codes in an unordered fashion.static HashFunction
concatenating(HashFunction first, HashFunction second, HashFunction... rest)
Returns a hash function which computes its hash code by concatenating the hash codes of the underlying hash functions together.static HashFunction
concatenating(Iterable<HashFunction> hashFunctions)
Returns a hash function which computes its hash code by concatenating the hash codes of the underlying hash functions together.static int
consistentHash(long input, int buckets)
Assigns toinput
a "bucket" in the range[0, buckets)
, in a uniform manner that minimizes the need for remapping asbuckets
grows.static int
consistentHash(HashCode hashCode, int buckets)
Assigns tohashCode
a "bucket" in the range[0, buckets)
, in a uniform manner that minimizes the need for remapping asbuckets
grows.static HashFunction
crc32()
Returns a hash function implementing the CRC32 checksum algorithm (32 hash bits).static HashFunction
crc32c()
Returns a hash function implementing the CRC32C checksum algorithm (32 hash bits) as described by RFC 3720, Section 12.1.static HashFunction
farmHashFingerprint64()
Returns a hash function implementing FarmHash's Fingerprint64, an opensource algorithm.static HashFunction
fingerprint2011()
Returns a hash function implementing the Fingerprint2011 hashing function (64 hash bits).static HashFunction
goodFastHash(int minimumBits)
Returns a generalpurpose, temporaryuse, noncryptographic hash function.static HashFunction
hmacMd5(byte[] key)
Returns a hash function implementing the Message Authentication Code (MAC) algorithm, using the MD5 (128 hash bits) hash function and aSecretKeySpec
created from the given byte array and the MD5 algorithm.static HashFunction
hmacMd5(Key key)
Returns a hash function implementing the Message Authentication Code (MAC) algorithm, using the MD5 (128 hash bits) hash function and the given secret key.static HashFunction
hmacSha1(byte[] key)
Returns a hash function implementing the Message Authentication Code (MAC) algorithm, using the SHA1 (160 hash bits) hash function and aSecretKeySpec
created from the given byte array and the SHA1 algorithm.static HashFunction
hmacSha1(Key key)
Returns a hash function implementing the Message Authentication Code (MAC) algorithm, using the SHA1 (160 hash bits) hash function and the given secret key.static HashFunction
hmacSha256(byte[] key)
Returns a hash function implementing the Message Authentication Code (MAC) algorithm, using the SHA256 (256 hash bits) hash function and aSecretKeySpec
created from the given byte array and the SHA256 algorithm.static HashFunction
hmacSha256(Key key)
Returns a hash function implementing the Message Authentication Code (MAC) algorithm, using the SHA256 (256 hash bits) hash function and the given secret key.static HashFunction
hmacSha512(byte[] key)
Returns a hash function implementing the Message Authentication Code (MAC) algorithm, using the SHA512 (512 hash bits) hash function and aSecretKeySpec
created from the given byte array and the SHA512 algorithm.static HashFunction
hmacSha512(Key key)
Returns a hash function implementing the Message Authentication Code (MAC) algorithm, using the SHA512 (512 hash bits) hash function and the given secret key.static HashFunction
md5()
Deprecated.If you must interoperate with a system that requires MD5, then use this method, despite its deprecation.static HashFunction
murmur3_128()
Returns a hash function implementing the 128bit murmur3 algorithm, x64 variant (littleendian variant), using a seed value of zero.static HashFunction
murmur3_128(int seed)
Returns a hash function implementing the 128bit murmur3 algorithm, x64 variant (littleendian variant), using the given seed value.static HashFunction
murmur3_32()
Deprecated.This implementation produces incorrect hash values from theHashFunction.hashString(java.lang.CharSequence, java.nio.charset.Charset)
method if the string contains nonBMP characters.static HashFunction
murmur3_32(int seed)
Deprecated.This implementation produces incorrect hash values from theHashFunction.hashString(java.lang.CharSequence, java.nio.charset.Charset)
method if the string contains nonBMP characters.static HashFunction
murmur3_32_fixed()
Returns a hash function implementing the 32bit murmur3 algorithm, x86 variant (littleendian variant), using a seed value of zero.static HashFunction
murmur3_32_fixed(int seed)
Returns a hash function implementing the 32bit murmur3 algorithm, x86 variant (littleendian variant), using the given seed value.static HashFunction
sha1()
Deprecated.If you must interoperate with a system that requires SHA1, then use this method, despite its deprecation.static HashFunction
sha256()
Returns a hash function implementing the SHA256 algorithm (256 hash bits).static HashFunction
sha384()
Returns a hash function implementing the SHA384 algorithm (384 hash bits).static HashFunction
sha512()
Returns a hash function implementing the SHA512 algorithm (512 hash bits).static HashFunction
sipHash24()
Returns a hash function implementing the 64bit SipHash24 algorithm using a seed value ofk = 00 01 02 ...
.static HashFunction
sipHash24(long k0, long k1)
Returns a hash function implementing the 64bit SipHash24 algorithm using the given seed.



Method Detail

goodFastHash
public static HashFunction goodFastHash(int minimumBits)
Returns a generalpurpose, temporaryuse, noncryptographic hash function. The algorithm the returned function implements is unspecified and subject to change without notice.Warning: a new random seed for these functions is chosen each time the
Hashing
class is loaded. Do not use this method if hash codes may escape the current process in any way, for example being sent over RPC, or saved to disk. For a generalpurpose, noncryptographic hash function that will never change behavior, we suggestmurmur3_128(int)
.Repeated calls to this method on the same loaded
Hashing
class, using the same value forminimumBits
, will return identicallybehavingHashFunction
instances. Parameters:
minimumBits
 a positive integer (can be arbitrarily large) Returns:
 a hash function, described above, that produces hash codes of length
minimumBits
or greater

murmur3_32
@Deprecated public static HashFunction murmur3_32(int seed)
Deprecated.This implementation produces incorrect hash values from theHashFunction.hashString(java.lang.CharSequence, java.nio.charset.Charset)
method if the string contains nonBMP characters. Usemurmur3_32_fixed(int)
instead.Returns a hash function implementing the 32bit murmur3 algorithm, x86 variant (littleendian variant), using the given seed value, with a known bug as described in the deprecation text.The C++ equivalent is the MurmurHash3_x86_32 function (Murmur3A), which however does not have the bug.

murmur3_32
@Deprecated public static HashFunction murmur3_32()
Deprecated.This implementation produces incorrect hash values from theHashFunction.hashString(java.lang.CharSequence, java.nio.charset.Charset)
method if the string contains nonBMP characters. Usemurmur3_32_fixed()
instead.Returns a hash function implementing the 32bit murmur3 algorithm, x86 variant (littleendian variant), using the given seed value, with a known bug as described in the deprecation text.The C++ equivalent is the MurmurHash3_x86_32 function (Murmur3A), which however does not have the bug.

murmur3_32_fixed
public static HashFunction murmur3_32_fixed(int seed)
Returns a hash function implementing the 32bit murmur3 algorithm, x86 variant (littleendian variant), using the given seed value.The exact C++ equivalent is the MurmurHash3_x86_32 function (Murmur3A).
This method is called
murmur3_32_fixed
because it fixes a bug in theHashFunction
returned by the originalmurmur3_32
method. Since:
 31.0

murmur3_32_fixed
public static HashFunction murmur3_32_fixed()
Returns a hash function implementing the 32bit murmur3 algorithm, x86 variant (littleendian variant), using a seed value of zero.The exact C++ equivalent is the MurmurHash3_x86_32 function (Murmur3A).
This method is called
murmur3_32_fixed
because it fixes a bug in theHashFunction
returned by the originalmurmur3_32
method. Since:
 31.0

murmur3_128
public static HashFunction murmur3_128(int seed)
Returns a hash function implementing the 128bit murmur3 algorithm, x64 variant (littleendian variant), using the given seed value.The exact C++ equivalent is the MurmurHash3_x64_128 function (Murmur3F).

murmur3_128
public static HashFunction murmur3_128()
Returns a hash function implementing the 128bit murmur3 algorithm, x64 variant (littleendian variant), using a seed value of zero.The exact C++ equivalent is the MurmurHash3_x64_128 function (Murmur3F).

sipHash24
public static HashFunction sipHash24()
Returns a hash function implementing the 64bit SipHash24 algorithm using a seed value ofk = 00 01 02 ...
. Since:
 15.0

sipHash24
public static HashFunction sipHash24(long k0, long k1)
Returns a hash function implementing the 64bit SipHash24 algorithm using the given seed. Since:
 15.0

md5
@Deprecated public static HashFunction md5()
Deprecated.If you must interoperate with a system that requires MD5, then use this method, despite its deprecation. But if you can choose your hash function, avoid MD5, which is neither fast nor secure. As of January 2017, we suggest: For security:
sha256()
or a higherlevel API.  For speed:
goodFastHash(int)
, though see its docs for caveats.
Returns a hash function implementing the MD5 hash algorithm (128 hash bits).  For security:

sha1
@Deprecated public static HashFunction sha1()
Deprecated.If you must interoperate with a system that requires SHA1, then use this method, despite its deprecation. But if you can choose your hash function, avoid SHA1, which is neither fast nor secure. As of January 2017, we suggest: For security:
sha256()
or a higherlevel API.  For speed:
goodFastHash(int)
, though see its docs for caveats.
Returns a hash function implementing the SHA1 algorithm (160 hash bits).  For security:

sha256
public static HashFunction sha256()
Returns a hash function implementing the SHA256 algorithm (256 hash bits).

sha384
public static HashFunction sha384()
Returns a hash function implementing the SHA384 algorithm (384 hash bits). Since:
 19.0

sha512
public static HashFunction sha512()
Returns a hash function implementing the SHA512 algorithm (512 hash bits).

hmacMd5
public static HashFunction hmacMd5(Key key)
Returns a hash function implementing the Message Authentication Code (MAC) algorithm, using the MD5 (128 hash bits) hash function and the given secret key. Parameters:
key
 the secret key Throws:
IllegalArgumentException
 if the given key is inappropriate for initializing this MAC Since:
 20.0

hmacMd5
public static HashFunction hmacMd5(byte[] key)
Returns a hash function implementing the Message Authentication Code (MAC) algorithm, using the MD5 (128 hash bits) hash function and aSecretKeySpec
created from the given byte array and the MD5 algorithm. Parameters:
key
 the key material of the secret key Since:
 20.0

hmacSha1
public static HashFunction hmacSha1(Key key)
Returns a hash function implementing the Message Authentication Code (MAC) algorithm, using the SHA1 (160 hash bits) hash function and the given secret key. Parameters:
key
 the secret key Throws:
IllegalArgumentException
 if the given key is inappropriate for initializing this MAC Since:
 20.0

hmacSha1
public static HashFunction hmacSha1(byte[] key)
Returns a hash function implementing the Message Authentication Code (MAC) algorithm, using the SHA1 (160 hash bits) hash function and aSecretKeySpec
created from the given byte array and the SHA1 algorithm. Parameters:
key
 the key material of the secret key Since:
 20.0

hmacSha256
public static HashFunction hmacSha256(Key key)
Returns a hash function implementing the Message Authentication Code (MAC) algorithm, using the SHA256 (256 hash bits) hash function and the given secret key. Parameters:
key
 the secret key Throws:
IllegalArgumentException
 if the given key is inappropriate for initializing this MAC Since:
 20.0

hmacSha256
public static HashFunction hmacSha256(byte[] key)
Returns a hash function implementing the Message Authentication Code (MAC) algorithm, using the SHA256 (256 hash bits) hash function and aSecretKeySpec
created from the given byte array and the SHA256 algorithm. Parameters:
key
 the key material of the secret key Since:
 20.0

hmacSha512
public static HashFunction hmacSha512(Key key)
Returns a hash function implementing the Message Authentication Code (MAC) algorithm, using the SHA512 (512 hash bits) hash function and the given secret key. Parameters:
key
 the secret key Throws:
IllegalArgumentException
 if the given key is inappropriate for initializing this MAC Since:
 20.0

hmacSha512
public static HashFunction hmacSha512(byte[] key)
Returns a hash function implementing the Message Authentication Code (MAC) algorithm, using the SHA512 (512 hash bits) hash function and aSecretKeySpec
created from the given byte array and the SHA512 algorithm. Parameters:
key
 the key material of the secret key Since:
 20.0

crc32c
public static HashFunction crc32c()
Returns a hash function implementing the CRC32C checksum algorithm (32 hash bits) as described by RFC 3720, Section 12.1.This function is best understood as a checksum rather than a true hash function.
 Since:
 18.0

crc32
public static HashFunction crc32()
Returns a hash function implementing the CRC32 checksum algorithm (32 hash bits).To get the
long
value equivalent toChecksum.getValue()
for aHashCode
produced by this function, useHashCode.padToLong()
.This function is best understood as a checksum rather than a true hash function.
 Since:
 14.0

adler32
public static HashFunction adler32()
Returns a hash function implementing the Adler32 checksum algorithm (32 hash bits).To get the
long
value equivalent toChecksum.getValue()
for aHashCode
produced by this function, useHashCode.padToLong()
.This function is best understood as a checksum rather than a true hash function.
 Since:
 14.0

farmHashFingerprint64
public static HashFunction farmHashFingerprint64()
Returns a hash function implementing FarmHash's Fingerprint64, an opensource algorithm.This is designed for generating persistent fingerprints of strings. It isn't cryptographically secure, but it produces a highquality hash with fewer collisions than some alternatives we've used in the past.
FarmHash fingerprints are encoded by
HashCode.asBytes()
in littleendian order. This meansHashCode.asLong()
is guaranteed to return the same value that farmhash::Fingerprint64() would for the same input (when compared usingUnsignedLongs
's encoding of 64bit unsigned numbers).This function is best understood as a fingerprint rather than a true hash function.
 Since:
 20.0

fingerprint2011
public static HashFunction fingerprint2011()
Returns a hash function implementing the Fingerprint2011 hashing function (64 hash bits).This is designed for generating persistent fingerprints of strings. It isn't cryptographically secure, but it produces a highquality hash with few collisions. Fingerprints generated using this are bytewise identical to those created using the C++ version, but note that this uses unsigned integers (see
UnsignedInts
). Comparisons between the two should take this into account.Fingerprint2011() is a form of Murmur2 on strings up to 32 bytes and a form of CityHash for longer strings. It could have been one or the other throughout. The main advantage of the combination is that CityHash has a bunch of special cases for short strings that don't need to be replicated here. The result will never be 0 or 1.
This function is best understood as a fingerprint rather than a true hash function.
 Since:
 NEXT

consistentHash
public static int consistentHash(HashCode hashCode, int buckets)
Assigns tohashCode
a "bucket" in the range[0, buckets)
, in a uniform manner that minimizes the need for remapping asbuckets
grows. That is,consistentHash(h, n)
equals:n  1
, with approximate probability1/n
consistentHash(h, n  1)
, otherwise (probability1  1/n
)
This method is suitable for the common use case of dividing work among buckets that meet the following conditions:
 You want to assign the same fraction of inputs to each bucket.
 When you reduce the number of buckets, you can accept that the most recently added
buckets will be removed first. More concretely, if you are dividing traffic among tasks,
you can decrease the number of tasks from 15 and 10, killing off the final 5 tasks, and
consistentHash
will handle it. If, however, you are dividing traffic among serversalpha
,bravo
, andcharlie
and you occasionally need to take each of the servers offline,consistentHash
will be a poor fit: It provides no way for you to specify which of the three buckets is disappearing. Thus, if your buckets change from[alpha, bravo, charlie]
to[bravo, charlie]
, it will assign all the oldalpha
traffic tobravo
and all the oldbravo
traffic tocharlie
, rather than lettingbravo
keep its traffic.
See the Wikipedia article on consistent hashing for more information.

consistentHash
public static int consistentHash(long input, int buckets)
Assigns toinput
a "bucket" in the range[0, buckets)
, in a uniform manner that minimizes the need for remapping asbuckets
grows. That is,consistentHash(h, n)
equals:n  1
, with approximate probability1/n
consistentHash(h, n  1)
, otherwise (probability1  1/n
)
This method is suitable for the common use case of dividing work among buckets that meet the following conditions:
 You want to assign the same fraction of inputs to each bucket.
 When you reduce the number of buckets, you can accept that the most recently added
buckets will be removed first. More concretely, if you are dividing traffic among tasks,
you can decrease the number of tasks from 15 and 10, killing off the final 5 tasks, and
consistentHash
will handle it. If, however, you are dividing traffic among serversalpha
,bravo
, andcharlie
and you occasionally need to take each of the servers offline,consistentHash
will be a poor fit: It provides no way for you to specify which of the three buckets is disappearing. Thus, if your buckets change from[alpha, bravo, charlie]
to[bravo, charlie]
, it will assign all the oldalpha
traffic tobravo
and all the oldbravo
traffic tocharlie
, rather than lettingbravo
keep its traffic.
See the Wikipedia article on consistent hashing for more information.

combineOrdered
public static HashCode combineOrdered(Iterable<HashCode> hashCodes)
Returns a hash code, having the same bit length as each of the input hash codes, that combines the information of these hash codes in an ordered fashion. That is, whenever two equal hash codes are produced by two calls to this method, it is as likely as possible that each was computed from the same input hash codes in the same order. Throws:
IllegalArgumentException
 ifhashCodes
is empty, or the hash codes do not all have the same bit length

combineUnordered
public static HashCode combineUnordered(Iterable<HashCode> hashCodes)
Returns a hash code, having the same bit length as each of the input hash codes, that combines the information of these hash codes in an unordered fashion. That is, whenever two equal hash codes are produced by two calls to this method, it is as likely as possible that each was computed from the same input hash codes in some order. Throws:
IllegalArgumentException
 ifhashCodes
is empty, or the hash codes do not all have the same bit length

concatenating
public static HashFunction concatenating(HashFunction first, HashFunction second, HashFunction... rest)
Returns a hash function which computes its hash code by concatenating the hash codes of the underlying hash functions together. This can be useful if you need to generate hash codes of a specific length.For example, if you need 1024bit hash codes, you could join two
sha512()
hash functions together:Hashing.concatenating(Hashing.sha512(), Hashing.sha512())
. Since:
 19.0

concatenating
public static HashFunction concatenating(Iterable<HashFunction> hashFunctions)
Returns a hash function which computes its hash code by concatenating the hash codes of the underlying hash functions together. This can be useful if you need to generate hash codes of a specific length.For example, if you need 1024bit hash codes, you could join two
sha512()
hash functions together:Hashing.concatenating(Hashing.sha512(), Hashing.sha512())
. Since:
 19.0

