位运算之——按位与（&）操作

  在hash中查找key的时候，经常会发现用&取代%，先看两段代码吧，

 

  JDK6中的HashMap中的indexFor方法：

Java代码  

1. /** 
2.  * Returns index for hash code h. 
3.  */  
4. static int indexFor(int h, int length) {  
5.     return h & (length-1);  
6. }  

 

Redis2.4中的代码段：

C代码  

1. n.size = realsize;  
2. n.sizemask = realsize-1;  
3. //此处略去xxx行  
4. hile(de) {  
5.         unsigned int h;  
6.   
7.         nextde = de->next;  
8.         /* Get the index in the new hash table */  
9.         h = dictHashKey(d, de->key) & d->ht[1].sizemask;  
10.         de->next = d->ht[1].table[h];  
11.         d->ht[1].table[h] = de;  
12.         d->ht[0].used--;  
13.         d->ht[1].used++;  
14.         de = nextde;  
15.     }  

 

大家可以看到a%b取模的形式都被替换成了a&(b-1) ，当hashtable的长度是2的幂的情况下（疏忽，一开始没写），这两者是等价的，那为什么要用后者呢？

另一方面，为什么hashtable的长度最好要是2的n次方呢，这个不在本次讨论范围之列，原因简单说一下就是1、分布更均匀 2、碰撞几率更小  详情自己思考，JDK中的HashMap就会在初始化时，保证这一点：

Java代码  

1. public HashMap(int initialCapacity, float loadFactor) {  
2.     if (initialCapacity < 0)  
3.         throw new IllegalArgumentException("Illegal initial capacity: " +  
4.                                            initialCapacity);  
5.     if (initialCapacity > MAXIMUM_CAPACITY)  
6.         initialCapacity = MAXIMUM_CAPACITY;  
7.     if (loadFactor <= 0 || Float.isNaN(loadFactor))  
8.         throw new IllegalArgumentException("Illegal load factor: " +  
9.                                            loadFactor);  
10.   
11.     // Find a power of 2 >= initialCapacity  
12.     int capacity = 1;  
13.     while (capacity < initialCapacity)  
14.         capacity <<= 1;  
15.   
16.     this.loadFactor = loadFactor;  
17.     threshold = (int)(capacity * loadFactor);  
18.     table = new Entry[capacity];  
19.     init();  
20. }  

 

redis中也有类似的保证：

 

Java代码  

1. /* Our hash table capability is a power of two */  
2. static unsigned long _dictNextPower(unsigned long size)  
3. {  
4.     unsigned long i = DICT_HT_INITIAL_SIZE;  
5.   
6.     if (size >= LONG_MAX) return LONG_MAX;  
7.     while(1) {  
8.         if (i >= size)  
9.             return i;  
10.         i *= 2;  
11.     }  
12. }  

 

 

言归正传，大家都知道位运算的效率最高，这也是&取代%的原因，来看个程序：

C代码  

1. int main(int argc, char* argv[])  
2. {  
3.     int a = 0x111;  
4.     int b = 0x222;  
5.     int c = 0;  
6.     int d = 0;  
7.   
8.     c = a & (b-1);  
9.     d = a % b;  
10.   
11.     return 0;  
12. }  

 

 

看反汇编的结果：

反汇编代码  

1. 13:       c = a & (b-1);  
2. 00401044   mov         eax,dword ptr [ebp-8]  
3. 00401047   sub         eax,1  
4. 0040104A   mov         ecx,dword ptr [ebp-4]  
5. 0040104D   and         ecx,eax  
6. 0040104F   mov         dword ptr [ebp-0Ch],ecx  
7. 14:       d = a % b;  
8. 00401052   mov         eax,dword ptr [ebp-4]  
9. 00401055   cdq  
10. 00401056   idiv        eax,dword ptr [ebp-8]  
11. 00401059   mov         dword ptr [ebp-10h],edx  

 

可以看到，&操作用了:3mov+1and+1sub  %操作用了：2mov+1cdp+1idiv

 

我们可以查阅Coding_ASM_-_Intel_Instruction_Set_Codes_and_Cycles资料，发现前者只需5个CPU周期，而后者至少需要26个CPU周期（注意，是最少！！！） 效率显而易见。所以以后自己在写的时候，也可以使用前者的写法。

===============================================================================================

由于位运算直接对内存数据进行操作，不需要转成十进制，因此处理速度非常快。

 常用技巧：

 

1、用于整数的奇偶性判断

 

一个整数a, a& 1 这个表达式可以用来判断a的奇偶性。二进制的末位为0表示偶数，最末位为1表示奇数。使用a%2来判断奇偶性和a & 1是一样的作用，但是a & 1要快好多。

2、判断n是否是2的正整数冪

 

(!(n&(n-1)))&& n

 

举个例子：

如果n = 16 =10000，n-1 = 1111

那么：

10000

& 1111

----------

          0

再举一个例子：如果n = 256 =100000000，n-1 = 11111111

那么：

100000000

&11111111

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

0

好！看完上面的两个小例子，相信大家都有一个感性的认识。从理论上讲，如果一个数a他是2的正整数幂，那么a 的二进制形式必定为1000…..（后面有0个或者多个0），那么结论就很显然了。

 

3、统计n中1的个数

 

朴素的统计办法是：先判断n的奇偶性，为奇数时计数器增加1，然后将n右移一位，重复上面步骤，直到移位完毕。