java hash取余_二次方取余技术在HashMap的应用

取余计算对计算机来说是相对比较慢的，但是在许多场景下，例如循环队列指针的移动，hashmap的哈希操作都必须要做取余运算。

解决思路的大方向，其实跟用逻辑右移代替乘法一样(x*2 等价于 x << 1),也通过使用逻辑运算来替代取余。这里有一个规律，就是当N为2的次方(Power of two)，那么X％N == X&(N-1)。

简单验证一下，设N＝256，当X256,所有高位的部分都是256的倍数，高位部分被&屏蔽，相当于X转化为X－n*256，等式成立。

我们可以看看HashMap是如何运用这项技术的，首先HashMap通过算法过滤,使Hash表的容量保持为2的次方倍。

class="java" name="code">

/**

* Returns a power of two size for the given target capacity.

*/

static final int tableSizeFor(int cap) {

int n = cap - 1;

n |= n >>> 1;

n |= n >>> 2;

n |= n >>> 4;

n |= n >>> 8;

n |= n >>> 16;

return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;

}

当然也可以采用API简单的实现

/**

* Calculate the next power of 2, greater than or equal to x.

* From Hacker's Delight, Chapter 3, Harry S. Warren Jr.

*

* @param x Value to round up

* @return The next power of 2 from x inclusive

*/

public static int ceilingNextPowerOfTwo(final int x)

{

return 1 << (32 - Integer.numberOfLeadingZeros(x - 1));

}

我们看到HashMap的容量使有符号的int型，所以很容易猜到，最大容量是2的31次方(最高位为符号位)。

/**

* The maximum capacity, used if a higher value is implicitly specified

* by either of the constructors with arguments.

* MUST be a power of two <= 1<<30.

*/

static final int MAXIMUM_CAPACITY = 1 << 30;

假设容量为cap，key的hashcode为h，HashMap使用tab数组存放元素，元素在数组的下标位置index ＝ tab[h&(cap-1)],我们看看核心的getNode方法实现

final Node getNode(int hash, Object key) {

Node[] tab; Node first, e; int n; K k;

if ((tab = table) != null && (n = tab.length) > 0 &&

(first = tab[(n - 1) & hash) != null) {

if (first.hash == hash && // always check first node

((k = first.key) == key || (key != null && key.equals(k))))

return first;

if ((e = first.next) != null) {

if (first instanceof TreeNode)

return ((TreeNode)first).getTreeNode(hash, key);

do {

if (e.hash == hash &&

((k = e.key) == key || (key != null && key.equals(k))))

return e;

} while ((e = e.next) != null);

}

}

return null;

}