Пример #1
0
 /** Get the md5 of the given key. */
 public static byte[] computeMd5(String k) {
   MessageDigest md5;
   try {
     md5 = MessageDigest.getInstance("MD5");
   } catch (NoSuchAlgorithmException e) {
     throw new RuntimeException("MD5 not supported", e);
   }
   md5.reset();
   md5.update(ByteUtils.getBytes(k));
   return md5.digest();
 }
Пример #2
0
  /**
   * Compute the hash for the given key.
   *
   * @return a positive integer hash
   */
  public long hash(final String k) {
    long rv = 0;
    switch (this) {
      case NATIVE_HASH:
        rv = k.hashCode();
        break;
      case CRC32_HASH:
        // return (crc32(shift) >> 16) & 0x7fff;
        CRC32 crc32 = new CRC32();
        crc32.update(ByteUtils.getBytes(k));
        rv = crc32.getValue() >> 16 & 0x7fff;
        break;
      case FNV1_64_HASH:
        {
          // Thanks to [email protected] for the pointer
          rv = FNV_64_INIT;
          int len = k.length();
          for (int i = 0; i < len; i++) {
            rv *= FNV_64_PRIME;
            rv ^= k.charAt(i);
          }
        }
        break;
      case MurMurHash:
        ByteBuffer buf = ByteBuffer.wrap(k.getBytes());
        int seed = 0x1234ABCD;

        ByteOrder byteOrder = buf.order();
        buf.order(ByteOrder.LITTLE_ENDIAN);

        long m = 0xc6a4a7935bd1e995L;
        int r = 47;

        rv = seed ^ (buf.remaining() * m);

        long ky;
        while (buf.remaining() >= 8) {
          ky = buf.getLong();

          ky *= m;
          ky ^= ky >>> r;
          ky *= m;

          rv ^= ky;
          rv *= m;
        }

        if (buf.remaining() > 0) {
          ByteBuffer finish = ByteBuffer.allocate(8).order(ByteOrder.LITTLE_ENDIAN);
          // for big-endian version, do this first:
          // finish.position(8-buf.remaining());
          finish.put(buf).rewind();
          rv ^= finish.getLong();
          rv *= m;
        }

        rv ^= rv >>> r;
        rv *= m;
        rv ^= rv >>> r;
        buf.order(byteOrder);
        break;
      case FNV1A_64_HASH:
        {
          rv = FNV_64_INIT;
          int len = k.length();
          for (int i = 0; i < len; i++) {
            rv ^= k.charAt(i);
            rv *= FNV_64_PRIME;
          }
        }
        break;
      case FNV1_32_HASH:
        {
          rv = FNV_32_INIT;
          int len = k.length();
          for (int i = 0; i < len; i++) {
            rv *= FNV_32_PRIME;
            rv ^= k.charAt(i);
          }
        }
        break;
      case FNV1A_32_HASH:
        {
          rv = FNV_32_INIT;
          int len = k.length();
          for (int i = 0; i < len; i++) {
            rv ^= k.charAt(i);
            rv *= FNV_32_PRIME;
          }
        }
        break;
      case KETAMA_HASH:
        byte[] bKey = computeMd5(k);
        rv =
            (long) (bKey[3] & 0xFF) << 24
                | (long) (bKey[2] & 0xFF) << 16
                | (long) (bKey[1] & 0xFF) << 8
                | bKey[0] & 0xFF;
        break;

      case MYSQL_HASH:
        int nr2 = 4;
        for (int i = 0; i < k.length(); i++) {
          rv ^= ((rv & 63) + nr2) * k.charAt(i) + (rv << 8);
          nr2 += 3;
        }
        break;
      case ELF_HASH:
        long x = 0;
        for (int i = 0; i < k.length(); i++) {
          rv = (rv << 4) + k.charAt(i);
          if ((x = rv & 0xF0000000L) != 0) {
            rv ^= x >> 24;
            rv &= ~x;
          }
        }
        rv = rv & 0x7FFFFFFF;
        break;
      case RS_HASH:
        long b = 378551;
        long a = 63689;
        for (int i = 0; i < k.length(); i++) {
          rv = rv * a + k.charAt(i);
          a *= b;
        }
        rv = rv & 0x7FFFFFFF;
        break;
      case LUA_HASH:
        int step = (k.length() >> 5) + 1;
        rv = k.length();
        for (int len = k.length(); len >= step; len -= step) {
          rv = rv ^ (rv << 5) + (rv >> 2) + k.charAt(len - 1);
        }
      case ONE_AT_A_TIME:
        try {
          int hash = 0;
          for (byte bt : k.getBytes("utf-8")) {
            hash += (bt & 0xFF);
            hash += (hash << 10);
            hash ^= (hash >>> 6);
          }
          hash += (hash << 3);
          hash ^= (hash >>> 11);
          hash += (hash << 15);
          return hash;
        } catch (UnsupportedEncodingException e) {
          throw new IllegalStateException("Hash function error", e);
        }
      default:
        assert false;
    }

    return rv & 0xffffffffL; /* Truncate to 32-bits */
  }