我需要一个整数的快速哈希函数：
int hash(int n) { return ...; }
Java中是否存在某些东西？
我需要的最小属性是：
hash(n) & 1不会出现周期性。hash(n) & 1大约同样可能为0或1。答案 0 :(得分：4)
HashMap以及Guava基于散列的utilities，在hashCode()结果上使用以下方法来改善比特分布并防御较弱的哈希函数：
/*
* This method was written by Doug Lea with assistance from members of JCP
* JSR-166 Expert Group and released to the public domain, as explained at
* http://creativecommons.org/licenses/publicdomain
*
* As of 2010/06/11, this method is identical to the (package private) hash
* method in OpenJDK 7's java.util.HashMap class.
*/
static int smear(int hashCode) {
hashCode ^= (hashCode >>> 20) ^ (hashCode >>> 12);
return hashCode ^ (hashCode >>> 7) ^ (hashCode >>> 4);
}
答案 1 :(得分：3)
所以，我读了这个问题，认为这是一个非常好的数学问题，它可能不属于我的联盟。然后，我花了很多时间思考它，我真的相信我已经得到了答案：没有功能可以满足f（n）＆amp;的标准。对于n的连续值，1是非周期性的。
希望有人会告诉我我的推理是多么荒谬，但在那之前我认为这是正确的。
这里：任何二进制整数n可以表示为1 ... 0或1 ... 1，并且只有该位图的最低有效位将影响n＆amp;的结果。此外，下一个连续的整数n + 1将始终包含相反的最低有效位。因此，显然任何一系列连续整数在传递给函数n＆amp;时都会表现出2的周期。那么，是否有任何函数f（n）能够充分分布一系列连续的整数，从而消除周期性？
任何函数f（n）= n + c都会失败，因为c必须以0或1结尾，因此LSB将根据所选的常数翻转或保持不变。
以上也消除了所有琐碎案例的减法，但我还没有花时间分析进位行为，所以这里可能存在裂缝。
任何函数f（n）= c * n都会失败，因为如果c以0结尾，则LSB将始终为0，如果c以1结尾，则总是等于n的LSB。
任何函数f（n）= n ^ c都会因类似的推理而失败。幂函数将始终与n具有相同的LSB。
出于同样的原因，任何函数f（n）= c ^ n都会失败。
除法和模数对我来说有点不太直观，但基本上，任一选项的LSB最终都是通过减法确定的（已经排除）。模数也明显具有等于除数的周期。
不幸的是，我没有必要证明这一点，但我相信上述操作的任何组合最终都会失败。这让我相信我们可以排除任何先验函数，因为这些是用多项式实现的（泰勒系列？不是术语人）。
最后，我对乘坐火车回家的希望表明，计算钻头的数量是可行的;然而，这实际上也是一个周期性的功能。我想到的方式是，想象一下取任何十进制数字的总和。这个数字显然会从0到9，然后下降到1，从1到10，然后下降到2 ......它有一个周期，范围随着我们计数的越高而越来越高。我们实际上可以对二进制数字的总和做同样的事情，在这种情况下我们得到类似的东西：0,1,1,2,2，.... 5,5,6,6,7,7,8 ，8 ....
我是否遗漏了什么？
TL; DR我不认为你的问题有答案。
答案 2 :(得分：1)
[SO决定将我的“琐碎回答”转换成评论。试图添加一些小文本，看看它是否可以被愚弄]
除非你需要更广泛的哈希函数游侠..
NumberOfSetBits函数似乎与hashCode相差很多，因此看起来更适合您的需求。事实证明，在SO上已经有一个相当有效的算法。
请参阅Best algorithm to count the number of set bits in a 32-bit integer。
答案 3 :(得分：1)
我做了一些实验（见下面的测试程序）;在Galois域中计算2 ^ n，并且floor（A * sin（n））都很好地产生了一系列“随机”比特。我尝试了乘法同余随机数生成器和一些代数和CRC（类似于伽罗瓦域中的k * n），但没有一个表现良好。
地板（A * sin（n））方法是最简单和最快的; GF32中的2 ^ n计算需要大约64次乘法和1024次异或，但在线性反馈移位寄存器的上下文中，输出位的周期性非常好理解。
package com.example.math;
public class QuickHash {
interface Hasher
{
public int hash(int n);
}
static class MultiplicativeHasher1 implements Hasher
{
/* multiplicative random number generator
* from L'Ecuyer is x[n+1] = 1223106847 x[n] mod (2^32-5)
* http://dimsboiv.uqac.ca/Cours/C2012/8INF802_Hiv12/ref/paper/RNG/TableLecuyer.pdf
*/
final static long a = 1223106847L;
final static long m = (1L << 32)-5;
/*
* iterative step towards computing mod m
* (j*(2^32)+k) mod (2^32-5)
* = (j*(2^32-5)+j*5+k) mod (2^32-5)
* = (j*5+k) mod (2^32-5)
* repeat twice to get a number between 0 and 2^31+24
*/
private long quickmod(long x)
{
long j = x >>> 32;
long k = x & 0xffffffffL;
return j*5+k;
}
// treat n as unsigned before computation
@Override public int hash(int n) {
long h = a*(n&0xffffffffL);
long h2 = quickmod(quickmod(h));
return (int) (h2 >= m ? (h2-m) : h2);
}
@Override public String toString() { return getClass().getSimpleName(); }
}
/**
* computes (2^n) mod P where P is the polynomial in GF2
* with coefficients 2^(k+1) represented by the bits k=31:0 in "poly";
* coefficient 2^0 is always 1
*/
static class GF32Hasher implements Hasher
{
static final public GF32Hasher CRC32 = new GF32Hasher(0x82608EDB, 32);
final private int poly;
final private int ofs;
public GF32Hasher(int poly, int ofs) {
this.ofs = ofs;
this.poly = poly;
}
static private long uint(int x) { return x&0xffffffffL; }
// modulo GF2 via repeated subtraction
int mod(long n) {
long rem = n;
long q = uint(this.poly);
q = (q << 32) | (1L << 31);
long bitmask = 1L << 63;
for (int i = 0; i < 32; ++i, bitmask >>>= 1, q >>>= 1)
{
if ((rem & bitmask) != 0)
rem ^= q;
}
return (int) rem;
}
int mul(int x, int y)
{
return mod(uint(x)*uint(y));
}
int pow2(int n) {
// compute 2^n mod P using repeated squaring
int y = 1;
int x = 2;
while (n > 0)
{
if ((n&1) != 0)
y = mul(y,x);
x = mul(x,x);
n = n >>> 1;
}
return y;
}
@Override public int hash(int n) {
return pow2(n+this.ofs);
}
@Override public String toString() {
return String.format("GF32[%08x, ofs=%d]", this.poly, this.ofs);
}
}
static class QuickHasher implements Hasher
{
@Override public int hash(int n) {
return (int) ((131111L*n)^n^(1973*n)%7919);
}
@Override public String toString() { return getClass().getSimpleName(); }
}
// adapted from http://www.w3.org/TR/PNG-CRCAppendix.html
static class CRC32TableHasher implements Hasher
{
final private int table[];
static final private int polyval = 0xedb88320;
public CRC32TableHasher()
{
this.table = make_table();
}
/* Make the table for a fast CRC. */
static public int[] make_table()
{
int[] table = new int[256];
int c;
int n, k;
for (n = 0; n < 256; n++) {
c = n;
for (k = 0; k < 8; k++) {
if ((c & 1) != 0)
c = polyval ^ (c >>> 1);
else
c = c >>> 1;
}
table[n] = (int) c;
}
return table;
}
public int iterate(int state, int i)
{
return this.table[(state ^ i) & 0xff] ^ (state >>> 8);
}
@Override public int hash(int n) {
int h = -1;
h = iterate(h, n >>> 24);
h = iterate(h, n >>> 16);
h = iterate(h, n >>> 8);
h = iterate(h, n);
return h ^ -1;
}
@Override public String toString() { return getClass().getSimpleName(); }
}
static class TrigHasher implements Hasher
{
@Override public String toString() { return getClass().getSimpleName(); }
@Override public int hash(int n) {
double s = Math.sin(n);
return (int) Math.floor((1<<31)*s);
}
}
private static void test(Hasher hasher) {
System.out.println(hasher+":");
for (int i = 0; i < 64; ++i)
{
int h = hasher.hash(i);
System.out.println(String.format("%08x -> %08x %%2 = %d",
i,h,(h&1)));
}
for (int i = 0; i < 256; ++i)
{
System.out.print(hasher.hash(i) & 1);
}
System.out.println();
analyzeBits(hasher);
}
private static void analyzeBits(Hasher hasher) {
final int N = 65536;
final int maxrunlength=32;
int[][] runs = {new int[maxrunlength], new int[maxrunlength]};
int[] count = new int[2];
int prev = -1;
System.out.println("Run length test of "+N+" bits");
for (int i = 0; i < maxrunlength; ++i)
{
runs[0][i] = 0;
runs[1][i] = 0;
}
int runlength_minus1 = 0;
for (int i = 0; i < N; ++i)
{
int b = hasher.hash(i) & 0x1;
count[b]++;
if (b == prev)
++runlength_minus1;
else if (i > 0)
{
++runs[prev][runlength_minus1];
runlength_minus1 = 0;
}
prev = b;
}
++runs[prev][runlength_minus1];
System.out.println(String.format("%d zeros, %d ones", count[0], count[1]));
for (int i = 0; i < maxrunlength; ++i)
{
System.out.println(String.format("%d runs of %d zeros, %d runs of %d ones", runs[0][i], i+1, runs[1][i], i+1));
}
}
public static void main(String[] args) {
Hasher[] hashers = {
new MultiplicativeHasher1(),
GF32Hasher.CRC32,
new QuickHasher(),
new CRC32TableHasher(),
new TrigHasher()
};
for (Hasher hasher : hashers)
{
test(hasher);
}
}
}
答案 4 :(得分：-1)
int 值的最简单散列是 int 值。
public int hashCode()
public static int hashCode(int value)
返回：
<块引用>此对象的哈希码值，等于此 Integer 对象表示的原始 int 值。