java.lang.Object
- com.google.common.hash.Hashing

```
@Beta
public final class Hashing
extends java.lang.Object
```
Static methods to obtain HashFunction instances, and other static hashing-related utilities.
A comparison of the various hash functions can be found here.

Since:

11.0

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description
`private static class`	`Hashing.Adler32Holder`
`(package private) static class`	`Hashing.ChecksumType`
`private static class`	`Hashing.ConcatenatedHashFunction`
`private static class`	`Hashing.Crc32cHolder`
`private static class`	`Hashing.Crc32Holder`
`private static class`	`Hashing.FarmHashFingerprint64Holder`
`private static class`	`Hashing.LinearCongruentialGenerator`	Linear CongruentialGenerator to use for consistent hashing.
`private static class`	`Hashing.Md5Holder`
`private static class`	`Hashing.Murmur3_128Holder`
`private static class`	`Hashing.Murmur3_32Holder`
`private static class`	`Hashing.Sha1Holder`
`private static class`	`Hashing.Sha256Holder`
`private static class`	`Hashing.Sha384Holder`
`private static class`	`Hashing.Sha512Holder`
`private static class`	`Hashing.SipHash24Holder`

Field Summary

Fields
Modifier and Type	Field	Description
`private static int`	`GOOD_FAST_HASH_SEED`	Used to randomize `goodFastHash(int)` instances, so that programs which persist anything dependent on the hash codes they produce will fail sooner.

Constructor Summary

Constructors
Modifier Constructor Description

private Hashing()

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method	Description
`static HashFunction`	`adler32()`	Returns a hash function implementing the Adler-32 checksum algorithm (32 hash bits) by delegating to the `Adler32` `Checksum`.
`(package private) static int`	`checkPositiveAndMakeMultipleOf32(int bits)`	Checks that the passed argument is positive, and ceils it to a multiple of 32.
`private static HashFunction`	`checksumHashFunction(Hashing.ChecksumType type, java.lang.String toString)`
`static HashCode`	`combineOrdered(java.lang.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(java.lang.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(java.lang.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 to `input` a "bucket" in the range `[0, buckets)`, in a uniform manner that minimizes the need for remapping as `buckets` grows.
`static int`	`consistentHash(HashCode hashCode, int buckets)`	Assigns to `hashCode` a "bucket" in the range `[0, buckets)`, in a uniform manner that minimizes the need for remapping as `buckets` grows.
`static HashFunction`	`crc32()`	Returns a hash function implementing the CRC-32 checksum algorithm (32 hash bits) by delegating to the `CRC32` `Checksum`.
`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 open-source algorithm.
`static HashFunction`	`goodFastHash(int minimumBits)`	Returns a general-purpose, temporary-use, non-cryptographic 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 a `SecretSpecKey` created from the given byte array and the MD5 algorithm.
`static HashFunction`	`hmacMd5(java.security.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 SHA-1 (160 hash bits) hash function and a `SecretSpecKey` created from the given byte array and the SHA-1 algorithm.
`static HashFunction`	`hmacSha1(java.security.Key key)`	Returns a hash function implementing the Message Authentication Code (MAC) algorithm, using the SHA-1 (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 SHA-256 (256 hash bits) hash function and a `SecretSpecKey` created from the given byte array and the SHA-256 algorithm.
`static HashFunction`	`hmacSha256(java.security.Key key)`	Returns a hash function implementing the Message Authentication Code (MAC) algorithm, using the SHA-256 (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 SHA-512 (512 hash bits) hash function and a `SecretSpecKey` created from the given byte array and the SHA-512 algorithm.
`static HashFunction`	`hmacSha512(java.security.Key key)`	Returns a hash function implementing the Message Authentication Code (MAC) algorithm, using the SHA-512 (512 hash bits) hash function and the given secret key.
`private static java.lang.String`	`hmacToString(java.lang.String methodName, java.security.Key key)`
`static HashFunction`	`md5()`	Returns a hash function implementing the MD5 hash algorithm (128 hash bits) by delegating to the MD5 `MessageDigest`.
`static HashFunction`	`murmur3_128()`	Returns a hash function implementing the 128-bit murmur3 algorithm, x64 variant (little-endian variant), using a seed value of zero.
`static HashFunction`	`murmur3_128(int seed)`	Returns a hash function implementing the 128-bit murmur3 algorithm, x64 variant (little-endian variant), using the given seed value.
`static HashFunction`	`murmur3_32()`	Returns a hash function implementing the 32-bit murmur3 algorithm, x86 variant (little-endian variant), using a seed value of zero.
`static HashFunction`	`murmur3_32(int seed)`	Returns a hash function implementing the 32-bit murmur3 algorithm, x86 variant (little-endian variant), using the given seed value.
`static HashFunction`	`sha1()`	Returns a hash function implementing the SHA-1 algorithm (160 hash bits) by delegating to the SHA-1 `MessageDigest`.
`static HashFunction`	`sha256()`	Returns a hash function implementing the SHA-256 algorithm (256 hash bits) by delegating to the SHA-256 `MessageDigest`.
`static HashFunction`	`sha384()`	Returns a hash function implementing the SHA-384 algorithm (384 hash bits) by delegating to the SHA-384 `MessageDigest`.
`static HashFunction`	`sha512()`	Returns a hash function implementing the SHA-512 algorithm (512 hash bits) by delegating to the SHA-512 `MessageDigest`.
`static HashFunction`	`sipHash24()`	Returns a hash function implementing the 64-bit SipHash-2-4 algorithm using a seed value of `k = 00 01 02 ...`.
`static HashFunction`	`sipHash24(long k0, long k1)`	Returns a hash function implementing the 64-bit SipHash-2-4 algorithm using the given seed.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - GOOD_FAST_HASH_SEED
```
private static final int GOOD_FAST_HASH_SEED
```
    Used to randomize goodFastHash(int) instances, so that programs which persist anything dependent on the hash codes they produce will fail sooner.
- Constructor Detail
  - Hashing
```
private Hashing()
```
- Method Detail
  - goodFastHash
```
public static HashFunction goodFastHash(int minimumBits)
```
    Returns a general-purpose, temporary-use, non-cryptographic 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.
    Repeated calls to this method on the same loaded Hashing class, using the same value for minimumBits, will return identically-behaving HashFunction 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
```
public static HashFunction murmur3_32(int seed)
```
    Returns a hash function implementing the 32-bit murmur3 algorithm, x86 variant (little-endian variant), using the given seed value.
    The exact C++ equivalent is the MurmurHash3_x86_32 function (Murmur3A).
  - murmur3_32
```
public static HashFunction murmur3_32()
```
    Returns a hash function implementing the 32-bit murmur3 algorithm, x86 variant (little-endian variant), using a seed value of zero.
    The exact C++ equivalent is the MurmurHash3_x86_32 function (Murmur3A).
  - murmur3_128
```
public static HashFunction murmur3_128(int seed)
```
    Returns a hash function implementing the 128-bit murmur3 algorithm, x64 variant (little-endian 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 128-bit murmur3 algorithm, x64 variant (little-endian 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 64-bit SipHash-2-4 algorithm using a seed value of k = 00 01 02 ....
    
    Since:
    
    15.0
  - sipHash24
```
public static HashFunction sipHash24(long k0,
                                     long k1)
```
    Returns a hash function implementing the 64-bit SipHash-2-4 algorithm using the given seed.
    
    Since:
    
    15.0
  - md5
```
public static HashFunction md5()
```
    Returns a hash function implementing the MD5 hash algorithm (128 hash bits) by delegating to the MD5 MessageDigest.
    Warning: MD5 is not cryptographically secure or collision-resistant and is not recommended for use in new code. It should be used for legacy compatibility reasons only. Please consider using a hash function in the SHA-2 family of functions (e.g., SHA-256).
  - sha1
```
public static HashFunction sha1()
```
    Returns a hash function implementing the SHA-1 algorithm (160 hash bits) by delegating to the SHA-1 MessageDigest.
    Warning: SHA1 is not cryptographically secure and is not recommended for use in new code. It should be used for legacy compatibility reasons only. Please consider using a hash function in the SHA-2 family of functions (e.g., SHA-256).
  - sha256
```
public static HashFunction sha256()
```
    Returns a hash function implementing the SHA-256 algorithm (256 hash bits) by delegating to the SHA-256 MessageDigest.
  - sha384
```
public static HashFunction sha384()
```
    Returns a hash function implementing the SHA-384 algorithm (384 hash bits) by delegating to the SHA-384 MessageDigest.
    
    Since:
    
    19.0
  - sha512
```
public static HashFunction sha512()
```
    Returns a hash function implementing the SHA-512 algorithm (512 hash bits) by delegating to the SHA-512 MessageDigest.
  - hmacMd5
```
public static HashFunction hmacMd5(java.security.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:
    
    java.lang.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 a SecretSpecKey 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(java.security.Key key)
```
    Returns a hash function implementing the Message Authentication Code (MAC) algorithm, using the SHA-1 (160 hash bits) hash function and the given secret key.
    
    Parameters:
    
    key - the secret key
    
    Throws:
    
    java.lang.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 SHA-1 (160 hash bits) hash function and a SecretSpecKey created from the given byte array and the SHA-1 algorithm.
    
    Parameters:
    
    key - the key material of the secret key
    
    Since:
    
    20.0
  - hmacSha256
```
public static HashFunction hmacSha256(java.security.Key key)
```
    Returns a hash function implementing the Message Authentication Code (MAC) algorithm, using the SHA-256 (256 hash bits) hash function and the given secret key.
    
    Parameters:
    
    key - the secret key
    
    Throws:
    
    java.lang.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 SHA-256 (256 hash bits) hash function and a SecretSpecKey created from the given byte array and the SHA-256 algorithm.
    
    Parameters:
    
    key - the key material of the secret key
    
    Since:
    
    20.0
  - hmacSha512
```
public static HashFunction hmacSha512(java.security.Key key)
```
    Returns a hash function implementing the Message Authentication Code (MAC) algorithm, using the SHA-512 (512 hash bits) hash function and the given secret key.
    
    Parameters:
    
    key - the secret key
    
    Throws:
    
    java.lang.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 SHA-512 (512 hash bits) hash function and a SecretSpecKey created from the given byte array and the SHA-512 algorithm.
    
    Parameters:
    
    key - the key material of the secret key
    
    Since:
    
    20.0
  - hmacToString
```
private static java.lang.String hmacToString(java.lang.String methodName,
                                             java.security.Key key)
```
  - 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.
    
    Since:
    
    18.0
  - crc32
```
public static HashFunction crc32()
```
    Returns a hash function implementing the CRC-32 checksum algorithm (32 hash bits) by delegating to the CRC32 Checksum.
    To get the long value equivalent to Checksum.getValue() for a HashCode produced by this function, use HashCode.padToLong().
    
    Since:
    
    14.0
  - adler32
```
public static HashFunction adler32()
```
    Returns a hash function implementing the Adler-32 checksum algorithm (32 hash bits) by delegating to the Adler32 Checksum.
    To get the long value equivalent to Checksum.getValue() for a HashCode produced by this function, use HashCode.padToLong().
    
    Since:
    
    14.0
  - checksumHashFunction
```
private static HashFunction checksumHashFunction(Hashing.ChecksumType type,
                                                 java.lang.String toString)
```
  - farmHashFingerprint64
```
public static HashFunction farmHashFingerprint64()
```
    Returns a hash function implementing FarmHash's Fingerprint64, an open-source algorithm.
    This is designed for generating persistent fingerprints of strings. It isn't cryptographically secure, but it produces a high-quality hash with fewer collisions than some alternatives we've used in the past. FarmHashFingerprints generated using this are byte-wise 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.
    
    Since:
    
    20.0
  - consistentHash
```
public static int consistentHash(HashCode hashCode,
                                 int buckets)
```
    Assigns to hashCode a "bucket" in the range [0, buckets), in a uniform manner that minimizes the need for remapping as buckets grows. That is, consistentHash(h, n) equals:
    
    n - 1, with approximate probability 1/n
    consistentHash(h, n - 1), otherwise (probability 1 - 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 servers alpha, bravo, and charlie 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 old alpha traffic to bravo and all the old bravo traffic to charlie, rather than letting bravo keep its traffic.
    
    See the Wikipedia article on consistent hashing for more information.
  - consistentHash
```
public static int consistentHash(long input,
                                 int buckets)
```
    Assigns to input a "bucket" in the range [0, buckets), in a uniform manner that minimizes the need for remapping as buckets grows. That is, consistentHash(h, n) equals:
    
    n - 1, with approximate probability 1/n
    consistentHash(h, n - 1), otherwise (probability 1 - 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 servers alpha, bravo, and charlie 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 old alpha traffic to bravo and all the old bravo traffic to charlie, rather than letting bravo keep its traffic.
    
    See the Wikipedia article on consistent hashing for more information.
  - combineOrdered
```
public static HashCode combineOrdered(java.lang.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:
    
    java.lang.IllegalArgumentException - if hashCodes is empty, or the hash codes do not all have the same bit length
  - combineUnordered
```
public static HashCode combineUnordered(java.lang.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:
    
    java.lang.IllegalArgumentException - if hashCodes is empty, or the hash codes do not all have the same bit length
  - checkPositiveAndMakeMultipleOf32
```
static int checkPositiveAndMakeMultipleOf32(int bits)
```
    Checks that the passed argument is positive, and ceils it to a multiple of 32.
  - 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 1024-bit hash codes, you could join two sha512() hash functions together: Hashing.concatenating(Hashing.sha512(), Hashing.sha512()).
    
    Since:
    
    19.0
  - concatenating
```
public static HashFunction concatenating(java.lang.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 1024-bit hash codes, you could join two sha512() hash functions together: Hashing.concatenating(Hashing.sha512(), Hashing.sha512()).
    
    Since:
    
    19.0

Class Hashing

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

GOOD_FAST_HASH_SEED

Constructor Detail

Hashing

Method Detail

goodFastHash

murmur3_32

murmur3_32

murmur3_128

murmur3_128

sipHash24

sipHash24

md5

sha1

sha256

sha384

sha512

hmacMd5

hmacMd5

hmacSha1

hmacSha1

hmacSha256

hmacSha256

hmacSha512

hmacSha512

hmacToString

crc32c

crc32

adler32

checksumHashFunction

farmHashFingerprint64

consistentHash

consistentHash

combineOrdered

combineUnordered

checkPositiveAndMakeMultipleOf32

concatenating

concatenating