Package com.google.common.hash

Class Hashing

  • public final class Hashing
extends 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
    Author:
    Kevin Bourrillion, Dimitris Andreou, Kurt Alfred Kluever

    • 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. For a general-purpose, non-cryptographic hash function that will never change behavior, we suggest murmur3_128(int).

        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. This can be arbitrarily large. The returned HashFunction instance may use memory proportional to this integer.
        Returns:
        a hash function, described above, that produces hash codes of length minimumBits or greater

      • murmur3_32_fixed

        public static HashFunction murmur3_32_fixed​(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).

        This method is called murmur3_32_fixed because it fixes a bug in the HashFunction returned by the original murmur3_32 method.

        Since:
        31.0

      • murmur3_32_fixed

        public static HashFunction murmur3_32_fixed()
        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).

        This method is called murmur3_32_fixed because it fixes a bug in the HashFunction returned by the original murmur3_32 method.

        Since:
        31.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:
        Returns a hash function implementing the MD5 hash algorithm (128 hash bits).

      • sha1

        @Deprecated
public static HashFunction sha1()
        Deprecated.
        If you must interoperate with a system that requires SHA-1, then use this method, despite its deprecation. But if you can choose your hash function, avoid SHA-1, which is neither fast nor secure. As of January 2017, we suggest:
        Returns a hash function implementing the SHA-1 algorithm (160 hash bits).

      • sha256

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

      • sha384

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

      • sha512

        public static HashFunction sha512()
        Returns a hash function implementing the SHA-512 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.

        If you are designing a new system that needs HMAC, prefer hmacSha256(java.security.Key) or other future-proof algorithms over hmacMd5.

        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 a SecretKeySpec created from the given byte array and the MD5 algorithm.

        If you are designing a new system that needs HMAC, prefer hmacSha256(java.security.Key) or other future-proof algorithms over hmacMd5.

        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 SHA-1 (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 SHA-1 (160 hash bits) hash function and a SecretKeySpec 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​(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:
        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 SecretKeySpec 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​(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:
        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 SecretKeySpec created from the given byte array and the SHA-512 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

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

        FarmHash fingerprints are encoded by HashCode.asBytes() in little-endian order. This means HashCode.asLong() is guaranteed to return the same value that farmhash::Fingerprint64() would for the same input (when compared using UnsignedLongs's encoding of 64-bit 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 high-quality hash with few collisions. Fingerprints 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.

        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:
        31.1

      • 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​(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

      • 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​(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