//初始化
int b = 0x08;
int b1 = 0x01;
int b2 = 0x09;
一、与(&) 有0为0，全1则1
//与运算 有0为0,同1异0
// b 0000 1000
// b1 0000 0001
// = 0000 0000 0
// b 0000 1000
// b2 0000 1001
// = 0000 1000 8
System.out.println("b & b1 = " + (b & b1));
System.out.println("b & b2 = " + (b & b2));
常见用法：
1、 取二进制的指定位数
比如取指定后4位，1101 0011 & 0000 1111 = 0000 0011、
所有位清零、判断奇偶(第i位是0还是1)
2、n & (n-1)
n &(n-1),结果一定是n中最低位的1翻转成0后的结果，举个例子：
n =7,
n &(n-1) = 7 & 6 = 0111 & 0110 = 0110 (结果是0111的最后一位反转为0后的值)
利用这特性可以在O(logn)时间复杂度内统计出n中1的个数。
二、或 (|) 有1为1，全0则0
//或运算 - 有1为1,同0则0
// b 0000 1000
// b1 0000 0001
// = 0000 1001 9
// b 0000 1000
// b2 0000 1001
// = 0000 1001 9
System.out.println("b | b1 = " + (b | b1));
System.out.println("b | b2 = " + (b | b2));
常见用法：
1、 指定位数置1
比如后4位置1
1101 0011 ｜ 0000 1111 = 1101 1111
2、高低位交换
交换一个数二进制位的高低位
1101 0011 右移4位，高位变低位 0000 1101 存入x；
1101 0011 左移动4位，低位变高位 0011 0000 存入y，
x | y = 0011 1101 即完成高低位交换
三、异或(^) 相等为0，不等为1
//按位异或，相等为0 ，不等为1
// b 0000 1000
// b1 0000 0001
// = 0000 1001 9
// b 0000 1000
// b2 0000 1001
// = 0000 0001 1
System.out.println("b ^ b1 = " + (b ^ b1));
System.out.println("b ^ b2 = " + (b ^ b2));
常见用法：
1、指定位反转
比如翻转后四位1101 0011 ^ 0000 1111 -> 1101 1100
2、两数交换
利用同0异1的性质，任何一个数异或自己结果都是0,任何一个数异或0，结果都是自己。
a = a^ b;
b = a ^ b = a^b^b = a ;
a = a ^ b = a ^ a ^ b = b;
从而达到两数交换的目的。
四、取反(～) 真值= 除符号位，按位取反+1
//按位取反
// 0000 0001 --反码--> 1111 1110(首位符号位) --表示的真值-->1000 0010(除去符号位，按位取反+1即为真值) -2
// 0000 1001 --反码--> 1111 0110(首位符号位) --表示的真值-->1000 1010(除去符号位，按位取反+1即为真值) -10
System.out.println("～b1 = " + (~ b1));
System.out.println("～b2 = " + (~ b2));
常见用法：
1、符号变换(负变正，正变负)
所有位取反+1,例如，
i = 9(0000 1001),
(~i) = 1111 0110，表示的真值为-10 (10001010)
(~i) + 1 = -9;
2、求整数绝对值
右移31位，则最高位变最低位，这个最低位就是符号位，如下：
i = a >> 31 ，绝对值 = (i == -1) ? (~a + 1) : a;
五、移位 >> (右移)、>>>(无符号右移)、<<(左移)
n & (1<<i) 可以快速判断，一个数的二进制第i位是不是1
六、真实题解
1、翻转一个二进制数的所有位数，例如(1011 -> 1101)
采用分治法，两位两位来交换,首先，拿到奇数位，右移一位，完成奇数位到偶数位(奇数位即两位中的高位)；再拿到偶数位，左移一位（偶数位即两位中的低位），再做|运算，完成两位内部的交换。举例：
a = 1011,
// 两位为一组，组内交换高低位
a = (1011 & 1010) >> 1 | (1011 & 0101) << 1 = 0111
再以两位为一组进行翻转，完成最终翻转。
a = (0111 & 1100) >> 2 | (0111 & 0011) >> 2 = 0001 | 1100 = 1101
2、Integer.bitCount源码详解(即，统计一个数的二进制位中1的个数，非常有意思)
/**
* Returns the number of one-bits in the two's complement binary
* representation of the specified {@code int} value. This function is
* sometimes referred to as the <i>population count</i>.
*
* @param i the value whose bits are to be counted
* @return the number of one-bits in the two's complement binary
* representation of the specified {@code int} value.
* @since 1.5
*/
public static int bitCount(int i) {
// HD, Figure 5-2
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;
}
思想：同样采用分治法，先两两位的计算1的数量，再将原来数值的二进制数中的每两位都改写为这两位中1的数量的二进制。
// 01相间
0x55555555 -> 0101 0101 0101 0101 0101 0101 0101 0101
// 两个0和两个1相间
0x33333333 -> 0011 0011 0011 0011 0011 0011 0011 0011
// 四个0和四个1相间
0x0f0f0f0f -> 0000 1111 0000 1111 0000 1111 0000 1111
//一个int类型数的二进制位中，1的个数不可能超过32个，用6位绰绰有余
0x3f -> 0011 1111
原理：
//i的二进式分解;
= b0*2^0 + b1*2^1 + ... + b31*2^31
// 无符号右移 i >>>1
= b1*2^0 + b2*2^1... + b31*2^30
// 与0x55555555 即：(i >>>1)& 0x55555555
= (b1*2^0 + b2*2^1... + b31*2^30) - (b2*2^1 + b4*2^3... + b30*2^29)
// i = i - (i >>>1)& 0x55555555,此时相当于每两位中1的个数相加,分为16组
= b0*2^0 + b1*2^1 + ... + b31*2^31 - (b1*2^0 + b2*2^1... + b31*2^30) + (b2*2^1 + b4*2^3... + b30*2^29)
= b0*2^0 + b1*(2^1 - 2^0) + b2*2^2 + ... + b30*2^30)+ b31*(2^31-2^30)
= b0*2^0 + b1*2^0 + b2*2^2 + ... + b30*2^30 + b31*2^30
= (b0+b1)*2^0 + (b2+b3)*2^2 + ... + (b30+b31)*2^30
// i = i & 0x33333333 + i >>> 1 & 0x33333333
= (b0+b1+b2+b3)*2^0 + (b4+b5+b6+b7)*2^4 + ... +(b28+b29+b30+b31)*2^28
// i= i >>> 4 + i & 0x0f0f0f0f
= (b0+b1+b2+b3+b4+b5+b6+b7)*2^0
+ (b8+b9+b10+b11+b12+b13+b14+b15)*2^8
+ (b16+b17+b18+b19+b20+b21+b22+b23)*2^16
+ (b24+b25+b26+b27+b28+b29+b30+b31)*2^24
//i = i + （i >>> 8）
= (b0+b1+b2+b3+b4+b5+b6+b7+b8+b9+b10+b11+b12+b13+b14+b15)*2^0
+ (b8+b9+b10+b11+b12+b13+b14+b15+b16+b17+b18+b19+b20+b21+b22+b23)*2^8
+ (b16+b17+b18+b19+b20+b21+b22+b23+b24+b25+b26+b27+b28+b29+b30+b31)*2^16
+ (b24+b25+b26+b27+b28+b29+b30+b31)*2^24
// i= i + i >>> 16，分为4组，只有第一组有效，其他组是垃圾数据
= (b0+b1+...+b31)*2^0
+ (b8+b9+...+b30+b31)*2^8
+ (b16+b17+...+b30+b31)*2^16
+ (b24+b25+b26+b27+b28+b29+b30+b31)*2^24
// i & 0x3f作为结果返回，与上0x3f时大于2^5的数据都被置0，6位二进制数足够表示32位int
= (b0+b1+...+b31)*2^0 & 0x00111111
= (b0+b1+...+b31)*2^0
= (b0+b1+...+b31)
参考资料https://echofzoe.gitee.io/blog/2021/06/22/bitCount%E6%BA%90%E7%A0%81%E8%A7%A3%E6%9E%90/
