├── README.txt
├── src
    └── util
    │   └── hash
    │       └── MurmurHash3.java
└── test
    └── util
        └── hash
            ├── TestHashSpeed.java
            └── TestMurmurHash3.java


/README.txt:
--------------------------------------------------------------------------------
 1 | Some random useful Java classes.
 2 | 
 3 | These are things too small for actual jars or releases
 4 | and are meant to just be copied into your own project.
 5 | As such, unless otherwise noted, this code has been
 6 | authored by Yonik Seeley and placed into the public domain
 7 | to allow people to use or license as they see fit.
 8 | 
 9 | util/hash/MurmurHash3: 
10 |   A fast, high quality hash function.  This version can also calculate
11 |   the hash of the UTF-8 encoding of a String without converting to a UTF-8 byte[].
12 | 
13 | 


--------------------------------------------------------------------------------
/src/util/hash/MurmurHash3.java:
--------------------------------------------------------------------------------
  1 | package util.hash;
  2 | 
  3 | /**
  4 |  *  The MurmurHash3 algorithm was created by Austin Appleby and placed in the public domain.
  5 |  *  This java port was authored by Yonik Seeley and also placed into the public domain.
  6 |  *  The author hereby disclaims copyright to this source code.
  7 |  *  <p>
  8 |  *  This produces exactly the same hash values as the final C++
  9 |  *  version of MurmurHash3 and is thus suitable for producing the same hash values across
 10 |  *  platforms.
 11 |  *  <p>
 12 |  *  The 32 bit x86 version of this hash should be the fastest variant for relatively short keys like ids.
 13 |  *  murmurhash3_x64_128 is a good choice for longer strings or if you need more than 32 bits of hash.
 14 |  *  <p>
 15 |  *  Note - The x86 and x64 versions do _not_ produce the same results, as the
 16 |  *  algorithms are optimized for their respective platforms.
 17 |  *  <p>
 18 |  *  See http://github.com/yonik/java_util for future updates to this file.
 19 |  */
 20 | public final class MurmurHash3 {
 21 | 
 22 |   /** 128 bits of state */
 23 |   public static final class LongPair {
 24 |     public long val1;
 25 |     public long val2;
 26 |   }
 27 | 
 28 |   public static final int fmix32(int h) {
 29 |     h ^= h >>> 16;
 30 |     h *= 0x85ebca6b;
 31 |     h ^= h >>> 13;
 32 |     h *= 0xc2b2ae35;
 33 |     h ^= h >>> 16;
 34 |     return h;
 35 |   }
 36 | 
 37 |   public static final long fmix64(long k) {
 38 |     k ^= k >>> 33;
 39 |     k *= 0xff51afd7ed558ccdL;
 40 |     k ^= k >>> 33;
 41 |     k *= 0xc4ceb9fe1a85ec53L;
 42 |     k ^= k >>> 33;
 43 |     return k;
 44 |   }
 45 | 
 46 |   /** Gets a long from a byte buffer in little endian byte order. */
 47 |   public static final long getLongLittleEndian(byte[] buf, int offset) {
 48 |     return     ((long)buf[offset+7]    << 56)   // no mask needed
 49 |             | ((buf[offset+6] & 0xffL) << 48)
 50 |             | ((buf[offset+5] & 0xffL) << 40)
 51 |             | ((buf[offset+4] & 0xffL) << 32)
 52 |             | ((buf[offset+3] & 0xffL) << 24)
 53 |             | ((buf[offset+2] & 0xffL) << 16)
 54 |             | ((buf[offset+1] & 0xffL) << 8)
 55 |             | ((buf[offset  ] & 0xffL));        // no shift needed
 56 |   }
 57 | 
 58 | 
 59 |   /** Returns the MurmurHash3_x86_32 hash. */
 60 |   @SuppressWarnings("fallthrough")
 61 |   public static int murmurhash3_x86_32(byte[] data, int offset, int len, int seed) {
 62 | 
 63 |     final int c1 = 0xcc9e2d51;
 64 |     final int c2 = 0x1b873593;
 65 | 
 66 |     int h1 = seed;
 67 |     int roundedEnd = offset + (len & 0xfffffffc);  // round down to 4 byte block
 68 | 
 69 |     for (int i=offset; i<roundedEnd; i+=4) {
 70 |       // little endian load order
 71 |       int k1 = (data[i] & 0xff) | ((data[i+1] & 0xff) << 8) | ((data[i+2] & 0xff) << 16) | (data[i+3] << 24);
 72 |       k1 *= c1;
 73 |       k1 = (k1 << 15) | (k1 >>> 17);  // ROTL32(k1,15);
 74 |       k1 *= c2;
 75 | 
 76 |       h1 ^= k1;
 77 |       h1 = (h1 << 13) | (h1 >>> 19);  // ROTL32(h1,13);
 78 |       h1 = h1*5+0xe6546b64;
 79 |     }
 80 | 
 81 |     // tail
 82 |     int k1 = 0;
 83 | 
 84 |     switch(len & 0x03) {
 85 |       case 3:
 86 |         k1 = (data[roundedEnd + 2] & 0xff) << 16;
 87 |         // fallthrough
 88 |       case 2:
 89 |         k1 |= (data[roundedEnd + 1] & 0xff) << 8;
 90 |         // fallthrough
 91 |       case 1:
 92 |         k1 |= (data[roundedEnd] & 0xff);
 93 |         k1 *= c1;
 94 |         k1 = (k1 << 15) | (k1 >>> 17);  // ROTL32(k1,15);
 95 |         k1 *= c2;
 96 |         h1 ^= k1;
 97 |     }
 98 | 
 99 |     // finalization
100 |     h1 ^= len;
101 | 
102 |     // fmix(h1);
103 |     h1 ^= h1 >>> 16;
104 |     h1 *= 0x85ebca6b;
105 |     h1 ^= h1 >>> 13;
106 |     h1 *= 0xc2b2ae35;
107 |     h1 ^= h1 >>> 16;
108 | 
109 |     return h1;
110 |   }
111 | 
112 | 
113 |   /** Returns the MurmurHash3_x86_32 hash of the UTF-8 bytes of the String without actually encoding
114 |    * the string to a temporary buffer.  This is more than 2x faster than hashing the result
115 |    * of String.getBytes().
116 |    */
117 |   public static int murmurhash3_x86_32(CharSequence data, int offset, int len, int seed) {
118 | 
119 |     final int c1 = 0xcc9e2d51;
120 |     final int c2 = 0x1b873593;
121 | 
122 |     int h1 = seed;
123 | 
124 |     int pos = offset;
125 |     int end = offset + len;
126 |     int k1 = 0;
127 |     int k2 = 0;
128 |     int shift = 0;
129 |     int bits = 0;
130 |     int nBytes = 0;   // length in UTF8 bytes
131 | 
132 | 
133 |     while (pos < end) {
134 |       int code = data.charAt(pos++);
135 |       if (code < 0x80) {
136 |         k2 = code;
137 |         bits = 8;
138 | 
139 |         /***
140 |         // optimized ascii implementation (currently slower!!! code size?)
141 |         if (shift == 24) {
142 |           k1 = k1 | (code << 24);
143 | 
144 |           k1 *= c1;
145 |           k1 = (k1 << 15) | (k1 >>> 17);  // ROTL32(k1,15);
146 |           k1 *= c2;
147 | 
148 |           h1 ^= k1;
149 |           h1 = (h1 << 13) | (h1 >>> 19);  // ROTL32(h1,13);
150 |           h1 = h1*5+0xe6546b64;
151 | 
152 |           shift = 0;
153 |           nBytes += 4;
154 |           k1 = 0;
155 |         } else {
156 |           k1 |= code << shift;
157 |           shift += 8;
158 |         }
159 |         continue;
160 |        ***/
161 | 
162 |       }
163 |       else if (code < 0x800) {
164 |         k2 = (0xC0 | (code >> 6))
165 |                 | ((0x80 | (code & 0x3F)) << 8);
166 |         bits = 16;
167 |       }
168 |       else if (code < 0xD800 || code > 0xDFFF || pos>=end) {
169 |         // we check for pos>=end to encode an unpaired surrogate as 3 bytes.
170 |         k2 = (0xE0 | (code >> 12))
171 |                 | ((0x80 | ((code >> 6) & 0x3F)) << 8)
172 |                 | ((0x80 | (code & 0x3F)) << 16);
173 |         bits = 24;
174 |       } else {
175 |         // surrogate pair
176 |         // int utf32 = pos < end ? (int) data.charAt(pos++) : 0;
177 |         int utf32 = (int) data.charAt(pos++);
178 |         utf32 = ((code - 0xD7C0) << 10) + (utf32 & 0x3FF);
179 |         k2 = (0xff & (0xF0 | (utf32 >> 18)))
180 |              | ((0x80 | ((utf32 >> 12) & 0x3F))) << 8
181 |              | ((0x80 | ((utf32 >> 6) & 0x3F))) << 16
182 |              |  (0x80 | (utf32 & 0x3F)) << 24;
183 |         bits = 32;
184 |       }
185 | 
186 | 
187 |       k1 |= k2 << shift;
188 | 
189 |       // int used_bits = 32 - shift;  // how many bits of k2 were used in k1.
190 |       // int unused_bits = bits - used_bits; //  (bits-(32-shift)) == bits+shift-32  == bits-newshift
191 | 
192 |       shift += bits;
193 |       if (shift >= 32) {
194 |         // mix after we have a complete word
195 | 
196 |         k1 *= c1;
197 |         k1 = (k1 << 15) | (k1 >>> 17);  // ROTL32(k1,15);
198 |         k1 *= c2;
199 | 
200 |         h1 ^= k1;
201 |         h1 = (h1 << 13) | (h1 >>> 19);  // ROTL32(h1,13);
202 |         h1 = h1*5+0xe6546b64;
203 | 
204 |         shift -= 32;
205 |         // unfortunately, java won't let you shift 32 bits off, so we need to check for 0
206 |         if (shift != 0) {
207 |           k1 = k2 >>> (bits-shift);   // bits used == bits - newshift
208 |         } else {
209 |           k1 = 0;
210 |         }
211 |         nBytes += 4;
212 |       }
213 | 
214 |     } // inner
215 | 
216 |     // handle tail
217 |     if (shift > 0) {
218 |       nBytes += shift >> 3;
219 |       k1 *= c1;
220 |       k1 = (k1 << 15) | (k1 >>> 17);  // ROTL32(k1,15);
221 |       k1 *= c2;
222 |       h1 ^= k1;
223 |     }
224 | 
225 |     // finalization
226 |     h1 ^= nBytes;
227 | 
228 |     // fmix(h1);
229 |     h1 ^= h1 >>> 16;
230 |     h1 *= 0x85ebca6b;
231 |     h1 ^= h1 >>> 13;
232 |     h1 *= 0xc2b2ae35;
233 |     h1 ^= h1 >>> 16;
234 | 
235 |     return h1;
236 |   }
237 | 
238 | 
239 |   /** Returns the MurmurHash3_x64_128 hash, placing the result in "out". */
240 |   @SuppressWarnings("fallthrough")
241 |   public static void murmurhash3_x64_128(byte[] key, int offset, int len, int seed, LongPair out) {
242 |     // The original algorithm does have a 32 bit unsigned seed.
243 |     // We have to mask to match the behavior of the unsigned types and prevent sign extension.
244 |     long h1 = seed & 0x00000000FFFFFFFFL;
245 |     long h2 = seed & 0x00000000FFFFFFFFL;
246 | 
247 |     final long c1 = 0x87c37b91114253d5L;
248 |     final long c2 = 0x4cf5ad432745937fL;
249 | 
250 |     int roundedEnd = offset + (len & 0xFFFFFFF0);  // round down to 16 byte block
251 |     for (int i=offset; i<roundedEnd; i+=16) {
252 |         long k1 = getLongLittleEndian(key, i);
253 |         long k2 = getLongLittleEndian(key, i+8);
254 |         k1 *= c1; k1  = Long.rotateLeft(k1,31); k1 *= c2; h1 ^= k1;
255 |         h1 = Long.rotateLeft(h1,27); h1 += h2; h1 = h1*5+0x52dce729;
256 |         k2 *= c2; k2  = Long.rotateLeft(k2,33); k2 *= c1; h2 ^= k2;
257 |         h2 = Long.rotateLeft(h2,31); h2 += h1; h2 = h2*5+0x38495ab5;
258 |     }
259 | 
260 |     long k1 = 0;
261 |     long k2 = 0;
262 | 
263 |     switch (len & 15) {
264 |       case 15: k2  = (key[roundedEnd+14] & 0xffL) << 48;
265 |       case 14: k2 |= (key[roundedEnd+13] & 0xffL) << 40;
266 |       case 13: k2 |= (key[roundedEnd+12] & 0xffL) << 32;
267 |       case 12: k2 |= (key[roundedEnd+11] & 0xffL) << 24;
268 |       case 11: k2 |= (key[roundedEnd+10] & 0xffL) << 16;
269 |       case 10: k2 |= (key[roundedEnd+ 9] & 0xffL) << 8;
270 |       case  9: k2 |= (key[roundedEnd+ 8] & 0xffL);
271 |         k2 *= c2; k2  = Long.rotateLeft(k2, 33); k2 *= c1; h2 ^= k2;
272 |       case  8: k1  = ((long)key[roundedEnd+7]) << 56;
273 |       case  7: k1 |= (key[roundedEnd+6] & 0xffL) << 48;
274 |       case  6: k1 |= (key[roundedEnd+5] & 0xffL) << 40;
275 |       case  5: k1 |= (key[roundedEnd+4] & 0xffL) << 32;
276 |       case  4: k1 |= (key[roundedEnd+3] & 0xffL) << 24;
277 |       case  3: k1 |= (key[roundedEnd+2] & 0xffL) << 16;
278 |       case  2: k1 |= (key[roundedEnd+1] & 0xffL) << 8;
279 |       case  1: k1 |= (key[roundedEnd  ] & 0xffL);
280 |         k1 *= c1; k1  = Long.rotateLeft(k1,31); k1 *= c2; h1 ^= k1;
281 |     }
282 | 
283 |     //----------
284 |     // finalization
285 | 
286 |     h1 ^= len; h2 ^= len;
287 | 
288 |     h1 += h2;
289 |     h2 += h1;
290 | 
291 |     h1 = fmix64(h1);
292 |     h2 = fmix64(h2);
293 | 
294 |     h1 += h2;
295 |     h2 += h1;
296 | 
297 |     out.val1 = h1;
298 |     out.val2 = h2;
299 |   }
300 | 
301 | }
302 | 


--------------------------------------------------------------------------------
/test/util/hash/TestHashSpeed.java:
--------------------------------------------------------------------------------
 1 | package util.hash;
 2 | 
 3 | import junit.framework.TestCase;
 4 | 
 5 | import java.nio.charset.Charset;
 6 | 
 7 | 
 8 | /**
 9 |  * @author yonik
10 |  */
11 | public class TestHashSpeed {
12 |   static  Charset utf8Charset = Charset.forName("UTF-8");
13 | 
14 |   public static void main(String[] args) throws Exception {
15 |     int arg = 0;
16 |     int size = Integer.parseInt(args[arg++]);
17 |     int iter = Integer.parseInt(args[arg++]);
18 |     String method = args[arg++];
19 | 
20 |     byte[] arr = new byte[size];
21 |     for (int i=0; i<arr.length; i++) {
22 |       arr[i] = (byte)(i & 0x7f);
23 |     }
24 |     String s = new String(arr, "UTF-8");
25 | 
26 |     int ret = 0;
27 |     long start = System.currentTimeMillis();
28 | 
29 |     if (method == null || method.equals("murmur32"))  {
30 |       for (int i = 0; i<iter; i++) {
31 |         // change offset and len so internal conditionals aren't predictable
32 |         int offset = ret & 0x03;
33 |         int len = arr.length - offset - ((ret>>3)&0x03);
34 |         ret += MurmurHash3.murmurhash3_x86_32(arr, offset, len, i);
35 |       }
36 |     } else if (method.equals("slow_string")) {
37 |       for (int i = 0; i<iter; i++) {
38 |         // change offset and len so internal conditionals aren't predictable
39 |         int offset = ret & 0x03;
40 |         int len = arr.length - offset - ((ret>>3)&0x03);
41 |         byte[] utf8 = s.getBytes(utf8Charset);
42 |         ret += MurmurHash3.murmurhash3_x86_32(utf8, offset, len, i);
43 |       }
44 |     } else if (method.equals("fast_string")) {
45 |       for (int i = 0; i<iter; i++) {
46 |         // change offset and len so internal conditionals aren't predictable
47 |         int offset = ret & 0x03;
48 |         int len = arr.length - offset - ((ret>>3)&0x03);
49 |         ret += MurmurHash3.murmurhash3_x86_32(s, offset, len, i);
50 |       }
51 |     } else {
52 |       throw new RuntimeException("Unknown method " + method);
53 |     }
54 | 
55 |     long end = System.currentTimeMillis();
56 | 
57 |     System.out.println("method="+method + " result="+ ret + " throughput=" + 1000 * ((double)size)*iter/(end-start) );
58 | 
59 |   }
60 | 
61 | }
62 | 


--------------------------------------------------------------------------------
/test/util/hash/TestMurmurHash3.java:
--------------------------------------------------------------------------------
  1 | package util.hash;
  2 | 
  3 | import junit.framework.TestCase;
  4 | 
  5 | import java.nio.charset.Charset;
  6 | import java.util.Random;
  7 | 
  8 | /**
  9 |  * @author yonik
 10 |  */
 11 | public class TestMurmurHash3 extends TestCase {
 12 | 
 13 |   public void testCorrectValues() throws Exception {
 14 |     byte[] bytes = "Now is the time for all good men to come to the aid of their country".getBytes("UTF-8");
 15 |     int hash=0;
 16 |     for (int i=0; i<bytes.length; i++) {
 17 |       hash = hash*31+(bytes[i]&0xff);
 18 |       bytes[i] = (byte)hash;
 19 |     }
 20 | 
 21 |     // test different offsets.
 22 |     for (int offset = 0; offset<20; offset++) {
 23 |       // put the original bytes at the offset so the same hash will be generated
 24 |       byte[] arr = new byte[bytes.length + offset];
 25 |       System.arraycopy(bytes, 0, arr, offset, bytes.length);
 26 |       int seed = 1;
 27 |       MurmurHash3.LongPair result = new MurmurHash3.LongPair();
 28 |       for (int len=0; len<bytes.length; len++) {
 29 |         seed *= 0x9e3779b1;
 30 |         int h = MurmurHash3.murmurhash3_x86_32(arr, offset, len, seed);
 31 |         assertEquals(answers32[len], h);
 32 |         MurmurHash3.murmurhash3_x64_128(arr, offset, len, seed, result);
 33 |         assertEquals(answers128[len * 2], result.val1);
 34 |         assertEquals(answers128[len*2+1], result.val2);
 35 |       }
 36 |     }
 37 |   }
 38 | 
 39 |   static int[] answers32 = new int[] {0x11fd02eb,0x8dd65a73,0x29b074ba,0xcbcd43ce,0xb6463881,0xf6228557,0x3d55c634,0xa1bb9072,0x448402c6,0xb12bf3d4,0x18a71ccb,0x6ae5f185,0x9a482256,0xc686d7f2,0x8e8984d8,0x68a2491d,0xcc29b0e6,0x3e9130bd,0xc90defb3,0xf81c5978,0x15ff7f63,0x4ec16a7a,0xa08aa899,0x7317ffee,0x93752d34,0x400f8781,0x2358838c,0x6ecb8998,0x45a5c102,0x46ed68fd,0xfecb51c0,0x7a68c7db,0x9e334eab,0x21ea13b6,0xf184e92c,0xc016220d,0x7f6c9713,0x1e909123,0xb51a21b7,0x94c58881,0xe4e91bf0,0xde80a366,0xfd84005a,0x3361d373,0xe7d528cc,0x487275a7,0xf2290ee5,0x869992a8,0x63cdd341,0x8e94b334,0x1fc7bf11,0x5228b0,0xb4292b62,0x36ed3770,0xfe914519,0x7d9d1830,0xe1acfb60,0xc8b4d4b7,0xf1ec49ba,0xedbb8cc1,0xdc5b3ab1,0x7c7778ae,0x52bf68d,0xe0bb4148,0xfea36521,0xa0696ca5,0xf28df752,0xd82dccb6};
 40 |   static long[] answers128 = new long[] {0x6e54d3ad2be8e9a2L,0xd99e452d1cfc7decL,0x609c35d060cf37c1L,0x4ba03e78929b6807L,0xf4865522a8838216L,0xef8dc0ad3f5a0581L,0x8513b05a329d04ecL,0x2295dbef5a603ebcL,0xd0259c75fa8711b2L,0x311f78657cb7ecb9L,0x771d03baa6accef1L,0x596d9c3bde77e873L,0xdc177610450452dbL,0x5b85d931e890ef5eL,0x261f88eedccbbd36L,0xcba71c1101271139L,0xa3a125d270c03cL,0xc41e9d6ae4ef9d56L,0xf9b21d4d660517c0L,0x409d87f99aeb3ea9L,0x92d8e70ae59a864L,0xf4e12d297744d05aL,0xd894caa03d461dbeL,0x99d6ff317880f305L,0x145d42da3710d23aL,0x2812adb381c1d64aL,0xd90254532b45e323L,0xacbb43b768a7b276L,0x74573f58c60c3ddfL,0xc72b9b42a7cbbd69L,0xd1129837bea190a7L,0xa7b20418ce5d46f9L,0xa6d094d2a166f659L,0x10f66ed93811576eL,0x28d3553af07b8cfaL,0xdd3b57dcd4d98ec2L,0xcd57b4faccaf9764L,0x1e4001ee8b46813aL,0xc79f57499389029eL,0xf4f84142db2d7673L,0xfafc9890edaf9086L,0xc54472528c0fcd98L,0xd3ff4eff416c02b7L,0x47c8414e9fa28367L,0x78f0171da51288e6L,0x7f5046c28cd1b43aL,0xc38dacef191ad1f0L,0x6210c0aba8230563L,0x15e3cd836648fe66L,0x56a1797408568c1eL,0x9162e9b79d4f6689L,0x6fc7ba8e6135592dL,0x569e7feab218d54aL,0x93d21aac30f6029fL,0x4e7a938ca19a5fe5L,0x3c7dd68323efe355L,0x651993620ca49e3fL,0x9f0cc9127f8eca7L,0x3963f278753c4f44L,0x3f2ab0d0e62bb19fL,0x4d72a64283465629L,0xd9d958282564a987L,0xde019492e4164d94L,0xc319fb27d1d42455L,0xe788f28b58a0c025L,0xabb3f2ca571338b4L,0xaac4a40f227db268L,0x8f86a5605449d75aL,0xcc3999bd3c872160L,0x3010e16e331a57e2L,0xd43cfd0741d4ed2L,0x7954298caa472790L,0xfe5b6444abb41ceL,0xaff3b10d222afeafL,0xa5438bad24a5629eL,0xc474fa5e2ff33329L,0xbda083bc5d7b382bL,0xef31a1cda016673eL,0xda9b98b58bb7eff5L,0xe001283d41a1576L,0x6ee0f9ab35eb17ebL,0x5de93fcf7e7e0169L,0x3cd1756a735b7caL,0x582ded067b6714e9L,0x56194735c4168e94L,0xeeaf5a39dcf76088L,0xf9d9a9c7d1520670L,0xb98d7d405a177795L,0x3281c2365b5bc415L,0x85e4cfb23980f8b4L,0x484aee59fa5880bdL,0xe000f2daa2078018L,0xebff3a4bff725d23L,0x803e3c3dd2716703L,0x413e18195eb5b4bfL,0xce1ea41794fec551L,0xcbf65e356e2d69bdL,0x654a616738582ba7L,0x62e46d535f11c417L,0xbd11185034218fa2L,0x7c715d440eaa5fb1L,0xe68ad0d758ade8dL,0x3242a4d88ac3ba92L,0x10f1e6939ee06b78L,0x965d9c4109ab6eb4L,0x6bc256008b6083d5L,0xa8fb3b9666e0eb4dL,0x2d8a83366565a273L,0xa5eddde29cc59fc4L,0xfd1f7dc9866ceb19L,0x86c13e98272a7eb9L,0x11149397f635b42cL,0xcbf82258e2b85bf5L,0x37215737b1ab86fbL,0x44e5126c5c5f4ae5L,0x99fe7cce58649b93L,0xc455e6ddc7be80f0L,0xf93bec96644e8723L,0x130dc4e99fb989e8L,0xb01734fafdc5308dL,0x8fde545bd48cb2feL,0x1102c89b77b4b405L,0x2cd24ed5816eca6eL,0xebd56473a502b63fL,0x357fb8e6b489be97L,0xe163a9495e6d67daL,0x87411ac34bd7399aL,0xf8bc18d84f4237bfL,0x43702207d2269e74L,0x37a3eec07a419e21L,0x7fe4605c33d4ac0cL,0x6df566b6925a898dL,0x89526c269d9225b0L,0xfc24aac3b731d33eL,0x2518f6ea6300c3caL,0xe4e20fdb203d79f5L};
 41 | 
 42 |   private final Charset utf8Charset = Charset.forName("UTF-8");
 43 | 
 44 |   private void doString(String s) {
 45 |     doString(s, 0, 0);
 46 |   }
 47 | 
 48 |   private void doString(String s, int pre, int post) {
 49 |     byte[] utf8 = s.getBytes(utf8Charset);
 50 |     int hash1 = MurmurHash3.murmurhash3_x86_32(utf8, pre, utf8.length-pre-post, 123456789);
 51 |     int hash2 = MurmurHash3.murmurhash3_x86_32(s, pre, s.length()-pre-post, 123456789);
 52 |     if (hash1 != hash2) {
 53 |       System.out.println(s);
 54 |       // second time for debugging...
 55 |       hash2 = MurmurHash3.murmurhash3_x86_32(s, pre, s.length()-pre-post, 123456789);
 56 |     }
 57 |     assertEquals(hash1, hash2);
 58 |   }
 59 | 
 60 |   public void testStringHash() {
 61 |     doString("hello!");
 62 |     doString("ABCD");
 63 |     doString("\u0123");
 64 |     doString("\u2345");
 65 |     doString("\u2345\u1234");
 66 | 
 67 |     Random r = new Random();
 68 |     StringBuilder sb = new StringBuilder(40);
 69 |     for (int i=0; i<100000; i++) {
 70 |       sb.setLength(0);
 71 |       int pre = r.nextInt(3);
 72 |       int post = r.nextInt(3);
 73 |       int len = r.nextInt(16);
 74 | 
 75 |       for (int j=0; j<pre; j++) {
 76 |         int codePoint = r.nextInt(0x80);
 77 |         sb.appendCodePoint(codePoint);
 78 |       }
 79 | 
 80 |       for (int j=0; j<len; j++) {
 81 |         int codePoint;
 82 |         do {
 83 |           int max = 0;
 84 |           switch (r.nextInt() & 0x3) {
 85 |             case 0: max=0x80; break;   // 1 UTF8 bytes
 86 |             case 1: max=0x800; break;  // up to 2 bytes
 87 |             case 2: max=0xffff+1; break; // up to 3 bytes
 88 |             case 3: max=Character.MAX_CODE_POINT+1; // up to 4 bytes
 89 |           }
 90 | 
 91 |           codePoint = r.nextInt(max);
 92 |         }  while (codePoint < 0xffff && (Character.isHighSurrogate((char)codePoint) || Character.isLowSurrogate((char)codePoint)));
 93 | 
 94 |         sb.appendCodePoint(codePoint);
 95 |       }
 96 | 
 97 |       for (int j=0; j<post; j++) {
 98 |         int codePoint = r.nextInt(0x80);
 99 |         sb.appendCodePoint(codePoint);
100 |       }
101 | 
102 |       String s = sb.toString();
103 |       String middle = s.substring(pre, s.length()-post);
104 | 
105 |       doString(s);
106 |       doString(middle);
107 |       doString(s, pre, post);
108 |     }
109 | 
110 |   }
111 | 
112 | }
113 | 
114 | 
115 | // Here is my C++ code to produce the list of answers to check against.
116 | /***************************************************
117 |  #include <iostream>
118 |  #include "MurmurHash3.h"
119 |  using namespace std;
120 | 
121 |  int main(int argc, char** argv) {
122 |    char* val = strdup("Now is the time for all good men to come to the aid of their country");
123 |    int max = strlen(val);
124 |    int hash=0;
125 |    for (int i=0; i<max; i++) {
126 |      hash = hash*31 + (val[i] & 0xff);
127 |       // we want to make sure that some high bits are set on the bytes
128 |       // to catch errors like signed vs unsigned shifting, etc.
129 |      val[i] = (char)hash;
130 |    }
131 |    uint32_t seed = 1;
132 |    for (int len=0; len<max; len++) {
133 |      seed = seed * 0x9e3779b1;
134 |      int result;
135 |      MurmurHash3_x86_32(val, len, seed, &result);
136 |      cout << "0x" << hex << result << ",";
137 |    }
138 |    cout << endl;
139 |    cout << endl;
140 |    // now 128 bit
141 |    seed = 1;
142 |    for (int len=0; len<max; len++) {
143 |      seed = seed * 0x9e3779b1;
144 |      long result[2];
145 |      MurmurHash3_x64_128(val, len, seed, &result);
146 |      cout << "0x" << hex << result[0] << "L,0x" << result[1] << "L," ;
147 |    }
148 | 
149 |    cout << endl;
150 |  }
151 |  ***************************************************/
152 | 


--------------------------------------------------------------------------------