bitCount()方法的功能是计算一个int类型数值的二进制补码中"1"的出现个数。
例如整数987654321的二进制是0011 1010 1101 1110 0110 1000 1011 0001，其中1出现的次数为17。
该方法的源码如下：
/**
* 返回指定int值的二进制补码二进制表示形式中的一位数
* 即统计指定int值的二进制补码中1的出现次数
* 例如整数987654321的二进制是0011 1010 1101 1110 0110 1000 1011 0001，其中1出现的次数为17
*
* @param i 要计数的值
* @return 返回指定int值的二进制补码中1的出现次数
*/
public static int bitCount(int i) {
i = i - ((i >>> 1) & 0x55555555);
i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);
i = (i + (i >>> 4)) & 0x0f0f0f0f;
i = i + (i >>> 8);
i = i + (i >>> 16);
return i & 0x3f;
}要理解bitCount()方法的原理，那么需要慢慢来，先看看bitCount()方法的原型：
public static int bitCount(int i) {
i = (i & 0x55555555) + ((i >>> 1) & 0x55555555);
i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);
i = (i & 0x0f0f0f0f) + ((i >>> 4) & 0x0f0f0f0f);
i = (i & 0x00ff00ff) + ((i >>> 8) & 0x00ff00ff);
i = (i & 0x0000ffff) + ((i >>> 16) & 0x0000ffff);
return i;
}思路就是：不断二分来统计1个出现次数，并且用移位的方式来记录1的个数。
- 例如，二进制00中高1位和低1位都是0，那么0+0也等于0，表示1的个数为00；
- 例如，二进制11中高1位和低1位都是0，那么眼睛观察有两个1，1+1等于10（这是二进制的加法得出的结果），表示1的个数有两个即10；
- 例如，二进制10中高1位和低1位分别为1和0，那么眼睛观察有一个1，1+0等于01，表示1的个数有一个即01。
上面是对三十二位二进制进行两两分组，可以分为16组，然后分别统计每一组中的1的个数。
接下来就是上一步结果再四四分组，分为8组，然后分别统计每一组中的1的个数。
- 例如，二进制0010中高2位00，低2位10，二者相加00+10等于10表示有2个1（这两个1是第一步统计出来的结果，继续往下计算）
- 例如，二进制0101中高2位01，低2位01，二者相加01+01等于10表示有2个1。
再接下来就是八八分组、十六十六分组、三十二三十二分组。
例如整数987654321的二进制是0011 1010 1101 1110 0110 1000 1011 0001，其中1出现的次数为17
两两分组，计算每组高1位和低1位中的1的个数，相加来计算
0011 1010 1101 1110 0110 1000 1011 0001
—— 00 11 10 10 11 01 11 10 01 10 10 00 10 11 00 01
—— 0+0 1+1 1+0 1+0 1+1 0+1 1+1 1+0 0+1 1+0 1+0 0+0 1+0 1+1 0+0 0+1
—— 00 10 01 01 10 01 10 01 01 01 01 00 01 10 00 01
四四分组，计算每组高2位和低2位中的1的个数，相加来计算
0010 0101 1001 1001 0101 0100 0110 0001
—— 0010 0101 1001 1001 0101 0100 0110 0001
—— 00+10 01+01 10+01 10+01 01+01 01+00 01+10 00+01
—— 0010 0010 0011 0011 0010 0001 0011 0001
八八分组，计算每组高4位和低4位中的1的个数，相加来计算
0010 0010 0011 0011 0010 0001 0011 0001
—— 00100010 00110011 00100001 00110001
—— 0010+0010 0011+0011 0010+0001 0011+0001
—— 00000100 00000110 00000011 00000100
十六十六分组，计算每组高8位和低8位中的1的个数，相加来计算
00000100 00000110 00000011 00000100
—— 0000010000000110 0000001100000100
—— 00000100+00000110 00000011+00000100
—— 0000000000001010 0000000000000111
三十二三十二分组，计算每组高16位和低16位中的1的个数，相加最后得到的二进制结果转换成十进制数就是该数中1的个数
0000000000001010 0000000000000111
—— 0000000000001010 0000000000000111
—— 0000000000001010+0000000000000111
—— 0000000000000000 0000000000010001
—— 17上面只是实现的思路而已，下面用代码的方式来一步一步地模拟这个过程：
public static int bitCount(int i) {
i = (i & 0x55555555) + ((i >>> 1) & 0x55555555);
i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);
i = (i & 0x0f0f0f0f) + ((i >>> 4) & 0x0f0f0f0f);
i = (i & 0x00ff00ff) + ((i >>> 8) & 0x00ff00ff);
i = (i & 0x0000ffff) + ((i >>> 16) & 0x0000ffff);
return i;
}
0x55555555 0101 0101 0101 0101 0101 0101 0101 0101
0x33333333 0011 0011 0011 0011 0011 0011 0011 0011
0x0f0f0f0f 0000 1111 0000 1111 0000 1111 0000 1111
0x00ff00ff 0000 0000 1111 1111 0000 0000 1111 1111
0x0000ffff 0000 0000 0000 0000 1111 1111 1111 1111
例如整数987654321的二进制是0011 1010 1101 1110 0110 1000 1011 0001，其中1出现的次数为17
①i = (i & 0x55555555) + ((i >>> 1) & 0x55555555);
(i & 0x55555555) 0011 1010 1101 1110 0110 1000 1011 0001
&
0101 0101 0101 0101 0101 0101 0101 0101
=0001 0000 0101 0100 0100 0000 0001 0001 保留每两位中的低1位
(i >>> 1) 0001 1101 0110 1111 0011 0100 0101 1000 将每二位原来的高1位1移动到低1位中
((i >>> 1) & 0x55555555)0001 1101 0110 1111 0011 0100 0101 1000
&
0101 0101 0101 0101 0101 0101 0101 0101
=0001 0101 0100 0101 0001 0100 0101 0000 保留每两位中的低1位（实际上是移动前中的每二位中的高1位）
(i & 0x55555555) + ((i >>> 1) & 0x55555555)
0001 0000 0101 0100 0100 0000 0001 0001
+
0001 0101 0100 0101 0001 0100 0101 0000
=0010 0101 1001 1001 0101 0100 0110 0001
②i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);
(i & 0x33333333) 0010 0101 1001 1001 0101 0100 0110 0001
&
0011 0011 0011 0011 0011 0011 0011 0011
=0010 0001 0001 0001 0001 0000 0010 0001 保留每四位中的低2位
(i >>> 2) 0000 1001 0110 0110 0101 0101 0001 1000 将每四位原来的高2位移动到低2位中
((i >>> 2) & 0x33333333) 0000 1001 0110 0110 0101 0101 0001 1000
&
0011 0011 0011 0011 0011 0011 0011 0011
=0000 0001 0010 0010 0001 0001 0001 0000 保留每四位中的低2位（实际上是移动前中的每四位中的高2位）
(i & 0x33333333) + ((i >>> 2) & 0x33333333)
0010 0001 0001 0001 0001 0000 0010 0001
+
0000 0001 0010 0010 0001 0001 0001 0000
=0010 0010 0011 0011 0010 0001 0011 0001
③i = (i & 0x0f0f0f0f) + ((i >>> 4) & 0x0f0f0f0f);
(i & 0x0f0f0f0f) 00100010 00110011 00100001 00110001
&
00001111 00001111 00001111 00001111
=00000010 00000011 00000001 00000001 保留每八位中的低4位
(i >>> 4) 00000010 00100011 00110010 00010011 将每八位原来的高4位移动到低4位中
((i >>> 4) & 0x0f0f0f0f) 00000010 00100011 00110010 00010011
&
00001111 00001111 00001111 00001111
=00000010 00000011 00000010 00000011 保留每八位中的低4位（实际上是移动前中的每八位中的高4位）
(i & 0x0f0f0f0f) + ((i >>> 4) & 0x0f0f0f0f)
00000010 00000011 00000001 00000001
+
00000010 00000011 00000010 00000011
=00000100 00000110 00000011 00000100
④i = (i & 0x00ff00ff) + ((i >>> 8) & 0x00ff00ff);
(i & 0x00ff00ff) 0000010000000110 0000001100000100
&
0000000011111111 0000000011111111
=0000000000000110 0000000000000100 保留每十六位位中的低8位
(i >>> 8) 0000000000000100 0000011000000011 将每八位原来的高8位移动到低8位中
((i >>> 8) & 0x00ff00ff) 0000000000000100 0000011000000011
&
0000000011111111 0000000011111111
=0000000000000100 0000000000000011 保留每十六位的低8位（实际上是移动前中的每十六位的高8位）
(i & 0x00ff00ff) + ((i >>> 8) & 0x00ff00ff)
0000000000000110 0000000000000100
+
0000000000000100 0000000000000011
=0000000000001010 0000000000000111
⑤i = (i & 0x0000ffff) + ((i >>> 16) & 0x0000ffff);
(i & 0x0000ffff) 00000000000010100000000000000111
&
00000000000000001111111111111111
=00000000000000000000000000000111 保留每三十二位的低16位
(i >>> 16) 00000000000000000000000000001010 将每八位原来的高16位移动到低16位中
((i >>> 16) & 0x0000ffff) 00000000000000000000000000001010
&
00000000000000001111111111111111
=00000000000000000000000000001010 保留每三十二位的低16位（实际上是移动前中的每三十二位的高16位）
(i & 0x0000ffff) + ((i >>> 16) & 0x0000ffff)
00000000000000000000000000000111
+
00000000000000000000000000001010
=00000000000000000000000000010001
=17（这就是最终的结果）如图：
比如四位二进制"0101"，我们要计算其中1的个数是要01+01=10，但是我们如何获得高2位"01"和低2位"01"，通过&0x33333333就可以获取每组中低2位的二进制了，那么要如何获取每组中高2位的二进制呢，就是将四位二进制无符号右移2位，即将"0101"无符号右移2位后的结果是"0001"这就获得了高2位的二进制了，再通过&0x33333333就可以真的可以获取每组中高2位的二进制了，之所以要&0x33333333是因为后面的加法运算排除其他数据。
如上，i&0x0f0f0f0f也是为了获取每组的低4位
如上，i&0x00ff00ff也是为了获取每组的低8位
如上，i&0x0000ffff也是为了获取每组中的低16位
而JDK中该方法的代码是优化过后效率更高的代码，但理解难度也大大提升：
public static int bitCount(int i) {
i = i - ((i >>> 1) & 0x55555555);
i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);
i = (i + (i >>> 4)) & 0x0f0f0f0f;
i = i + (i >>> 8);
i = i + (i >>> 16);
return i & 0x3f;
}第一行的优化是这样子的，我们知道01+01=10，这是通过加法计算得到的，但也可以通过减法得到，11-01=10，这就是通过减法计算得到的。（注：下面的代码没有用"0x55555555"而是用的是"0x5"，因为只有四位二进制参与模拟运算，所以只需要"0x5"转换成四位二进制参与运算即可，可以看到它们最终会得到相同的结果。但这个式子如何推导出来的仍不得而知。）
i=(i&0x5)+((i>>>1)&0x5)
=0011&0101+((i>>>1)&0x5)
=0001+((i>>>1)&0x5)
=0001+0001
=0010
i=i-((i>>>1)&0x5)
=0011-((i>>>1)&0x5)
=0011-0001
=0010第二行没有变化。
第三行，因为四位二进制可以表示最大15的数值（如二进制"1111"转换成十进制是15，所以可以表示15位的"1"），计算后用后四位表示一个八位的“1”数量足够，这样又可以少一次按位与运算，在上一步的时候两位二进制不足以表示四位二进制数的“1”的数量，为了效率，采用(i & 0x33333333) + ((i >>> 2) & 0x33333333)这种方式。计算后i的值所表示的二进制数表达的是每八位一个八位二进制数，每个八位二进制数的值表示这八位中“1”的数量，并且每个八位二进制数的前四位必然是0。
第四行、第五行只需要关注二进制的后六位就可以了，因为一个int类型的数是32位二进制，如果32位的二进制都是1，那么bitCount()方法得到的结果就是32，而2的6次方为64，我们的结果如"00000000000000000000000000010001"表示有17个1，这个17=1*2^0+0*2^1+0^2^2+0*2^3+1*2^4，而0x3f的二进制是"0000 0000 0000 0000 0000 0000 0011 1111"，转换成十进制数是1*2^0+1*2^1+1^2^2+1*2^3+1*2^4+1*2^5=63，所以一个int类型的数中的"1"的个数必然小于等于32位，即一定在"0000 0000 0000 0000 0000 0000 0011 1111"中的后6位中，而前面26位就不需要关心了，过滤掉即可，为了效率。
