## com.google.common.hash
Class Hashing

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

    @Beta
    public final class Hashing

extends Object

Static methods to obtain `HashFunction` instances, and other static hashing-related utilities.

Since:
  11.0
Author:
  Kevin Bourrillion, Dimitris Andreou, Kurt Alfred Kluever

Method Summary
`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 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 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 HashFunction` `goodFastHash(int minimumBits)` Returns a general-purpose, non-cryptographic-strength, streaming hash function that produces hash codes of length at least `minimumBits`.
`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 (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 (little-endian variant), using the given seed value.
`static long` `padToLong(HashCode hashCode)` If `hashCode` has enough bits, returns `hashCode.asLong()`, otherwise returns a `long` value with `hashCode.asInt()` as the least-significant four bytes and `0x00` as each of the most-significant four bytes.
`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` `sha512()` Returns a hash function implementing the SHA-512 algorithm (512 hash bits) by delegating to the SHA-512 `MessageDigest`.

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

Method Detail

### goodFastHash

    public static HashFunction goodFastHash(int minimumBits)

  Returns a general-purpose, non-cryptographic-strength, streaming hash function that produces hash codes of length at least `minimumBits`. Users without specific compatibility requirements and who do not persist the hash codes are encouraged to choose this hash function.

  Repeated calls to `goodFastHash(int)` with the same `minimumBits` value will return `HashFunction` instances with identical behavior (but not necessarily the same instance) for the duration of the current virtual machine.

  Warning: the implementation is unspecified and is subject to change.

  Throws:
    `IllegalArgumentException` - if `minimumBits` is not positive

### murmur3_32

    public static HashFunction murmur3_32(int seed)

  Returns a hash function implementing the 32-bit murmur3 algorithm (little-endian variant), using the given seed value.

### murmur3_32

    public static HashFunction murmur3_32()

  Returns a hash function implementing the 32-bit murmur3 algorithm (little-endian variant), using a seed value of zero.

### 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.

### 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.

### md5

    public static HashFunction md5()

  Returns a hash function implementing the MD5 hash algorithm (128 hash bits) by delegating to the MD5 `MessageDigest`.

### sha1

    public static HashFunction sha1()

  Returns a hash function implementing the SHA-1 algorithm (160 hash bits) by delegating to the SHA-1 `MessageDigest`.

### sha256

    public static HashFunction sha256()

  Returns a hash function implementing the SHA-256 algorithm (256 hash bits) by delegating to the SHA-256 `MessageDigest`.

### sha512

    public static HashFunction sha512()

  Returns a hash function implementing the SHA-512 algorithm (512 hash bits) by delegating to the SHA-512 `MessageDigest`.

### padToLong

    public static long padToLong(HashCode hashCode)

  If `hashCode` has enough bits, returns `hashCode.asLong()`, otherwise returns a `long` value with `hashCode.asInt()` as the least-significant four bytes and `0x00` as each of the most-significant four bytes.

### 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`)

  See the wikipedia article on consistent hashing for more information.

  If you might want to have weights for the buckets in the future, take a look at `weightedConsistentHash`.

### 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`)

  See the wikipedia article on consistent hashing for more information.

  If you might want to have weights for the buckets in the future, take a look at `weightedConsistentHash`.

### 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` - if `hashCodes` 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` - if `hashCodes` is empty, or the hash codes do not all have the same bit length

Copyright © 2010-2012. All Rights Reserved.