Java hashCode()

Each object class in the Java language provides an implementation of the hashCode() method. The output of this method is a 32-bit signed integer and the results are intended to be evenly distributed for varied inputs so as to avoid clustering when used in HashMap's and other structures that store objects in buckets based on their hashCode().

For the java.lang.String class, for instance, a hash code is computed according to the algorithm:

     s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]

using int (32-bit) arithmetic, where s[i] is the ith character of the string, n is the length of the string, and ^ indicates exponentiation.

This is not a cryptographically secure hash algorithm.

Sample Implementations

Java

NOTE: This is not the implementation of hashCode() in java.lang.String, but an example of how one would implement the function as a static method.

public static int hashCode(String input) {
    int h = 0;
    int len = input.length();
    for (int i = 0; i < len; i++) {
        h = 31 * h + input.charAt(i);
    }
    return h;
}

ActionScript (Flash)

NOTE: The >> operator behaves as described in the ActionScript documentation, which includes conversion of the inputs to 32-bit integers:
"Operator (bitwise); converts expression1 and expression2 to 32-bit integers, and shifts all of the bits in expression1 to the right by the number of places specified by the integer resulting from the conversion of expression2 . Bits that are shifted to the right are discarded. To preserve the sign of the original expression , the bits on the left are filled in with 0 if the most significant bit (the bit farthest to the left) of expression1 is 0, and filled in with 1 if the most significant bit is 1."

function hashCode(string) {
    var h = 0;
    for (var i = 0; i &lt; string.length; i++) {
        h = (((31 * h) &gt;&gt; 0) + string.charCodeAt(i)) &gt;&gt; 0;
    }
    return h;
}