本文探讨了位运算的基本概念，包括与、或、异或、取反、左移和右移操作，并通过实例展示了如何计算二进制中'1'的个数。接着深入分析了HashMap中位运算的应用，如计算数组下标和扩容过程，揭示了位运算在提高效率和解决冲突方面的优势。最后，文章提到了JDK中Integer.bitCount()的高效实现。
写在开头：本文为学习后的总结，可能有不到位的地方，错误的地方，欢迎各位指正。
目录
一、位运算初窥
1、位运算的简介
计算机中所有的数据二进制的形式存储在设备中，即 0、1 两种状态。计算机对二进制数据进行的运算(+、-、*、/)都是叫位运算，即将符号位共同参与运算的运算。
| 符号 | 描述 | 运算规则 |
|---|---|---|
| & | 与 | 两个位都为1时，结果才为1 0&0=0 0&1=0 1&0=0 1&1=1 |
| | | 或 | 两个位都为0时，结果才为0 0|0=0 0|1=1 1|0=1 1|1=1 |
| ^ | 异或 | 两个位相同为0，相异为1 0^0=0 0^1=1 1^0=1 1^1=0 |
| ~ | 取反 | 0变1，1变0 ~1=0 ~0=1 |
| << | 左移 | 各二进位全部左移若干位，高位丢弃，低位补0 1<<1=2 （01左移一位变为10，效果等同于*2） |
| >> | 右移 | 各二进位全部右移若干位，对无符号数，高位补0，有符号数，各编译器处理方法不一样，有的补符号位（算术右移），有的补0（逻辑右移） 2>>1=1 （10右移一位变为01，效果等同于/2） |
2、位运算的使用
举个例子，现在需要实现一个功能，给定一个32位无符号整数，需要计算其二进制表达式中数字位数为 '1' 的个数。比如：‘3’，可以得到结果为2（0000 0011）。
方法一：
依次遍历这32位并判断该位是否为1，计算出为1的位数。可以在32次循环内计算出结果。
public int hammingWeight(int n) {
int res = 0;
for (int i=0;i<32;i++) {
res+= n&1;
n>>=1;
}
return res;
}方法二：
在方法一的基础上，我们来进行优化。先说结论，使用n & (n - 1) ，这个代码可以把 n 的二进制中，最后一个出现的 1 改写成 0，下面来证明下。
n与n-1必然一个为偶数一个为奇数，因此他们的最低为必然分别为0和1。如果n为奇数，则其最低为为1，与n-1相与后可以将最低为消为0。反过来，如果n为偶数，同样可以将n中从右向左第一位为1的位数消为0。
1011（n=7）
& 1010（n=6）
-----------------
1010 = 6
1010（n=6）
& 1001（n=5）
-----------------
1000 = 4
于是我们可以得出如下代码。加入我们需要计算的入参为32，方法一需要循环5次才能计算出结果，而方法二则只需要计算1次即可。
public int hammingWeight(int n) {
int res = 0;
while (n != 0) {
n &= n - 1;
res++;
}
return res;
}但是方法二在遇到全为1的情况（如15，31）时，依然需要循环多次才能得出结果。对于这个问题，我们可以看下JDK提供的方法。
方法三：（JDK教做人系列）
在Integer中，JDK提供了专门的API用于计算二进制中‘1’的个数。
// java.lang.annotation.Native.Integer
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;
}以上源码对于任意数字均可以在常量时间内计算出结果。
但过于精简导致可读性较差下面我简单解释下过程，基本含义为分治的处理，先计算每2位的结果，然后计算每4位的结果，以此类推，最后的结果将会被记录在低8位中，使用i&0x3f来得到最终结果。 完整的验证过程可以看这里《Integer.bitCount() 函数理解》。
二、位运算在HashMap中的使用
通过上面的介绍，我们初步了解了位运算在JDK中的使用，下面我们来看下最常用的集合框架HashMap是如何使用位运算来进行优化的。
1、hash值与数组下标的计算
我们先从jdk1.7中的hash计算开始讲起，1.7中使用indexFor计算数组的下标。
static int indexFor(int h, int length) {
return h & (length-1);
}length为数组的长度，恒为2的n次幂，因此length-1的二进制表示，除最高位为0外，低位全部为1。假设这里length为8，有2个hash分别为3和15要计算索引，于是有：
length-1 0000 0111
3 0000 0011
--------------------------
& 0000 0011
=3
length-1 0000 0111
15 0000 1111
--------------------------
& 0000 0111
=7我们看到，对于一个长度为length的数组，假设其为2的n次幂，length-1的结果就是n个1，其与任何数（如上图中的3、15）相与的结果都是保留其低位，间接性的实现了取模的效果。但是我们为什么不直接取模呢，这是因为&运算直接使用二进制位计算，能更快的达到效果。由于数组长度恒为2的n次幂，所以该结论必然存在。这也是我们每次扩容都是2倍的原因之一。
在java8中我们采用同样的方法来计算索引下标，只不过计算过程放到了put方法当中。
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);理解了上面这一点，我们再来看java8中的hash计算：
static final int hash(Object key) {
int h;
// h = key.hashCode() 为第一步 取hashCode值
// h ^ (h >>> 16) 为第二步 高位参与运算
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
} 这里对于key.hashcode将其本身与自己无符号右移16位的结果相异或，参考下图。
把哈希值右移 16 位，也就正好是自己长度的一半，之后与原哈希值做异或运算，这样就混合了原哈希值中的高位和低位，不仅保留了低位的信息，还夹杂了高位的特征，大大增加了随机性。
2、扩容
依然还是从1.7的扩容源码入手，其内部会新建一个数组，然后通过transfer方法将原数组中的键值对依次加入到新数组中。
void resize(int newCapacity) { //传入新的容量
Entry[] oldTable = table; //引用扩容前的Entry数组
int oldCapacity = oldTable.length;
if (oldCapacity == MAXIMUM_CAPACITY) { //扩容前的数组大小如果已经达到最大(2^30)了
threshold = Integer.MAX_VALUE; //修改阈值为int的最大值(2^31-1)，这样以后就不会扩容了
return;
}
Entry[] newTable = new Entry[newCapacity]; //初始化一个新的Entry数组
transfer(newTable); //！！将数据转移到新的Entry数组里
table = newTable; //HashMap的table属性引用新的Entry数组
threshold = (int)(newCapacity * loadFactor);//修改阈值
}
void transfer(Entry[] newTable) {
Entry[] src = table; //src引用了旧的Entry数组
int newCapacity = newTable.length;
for (int j = 0; j < src.length; j++) { //遍历旧的Entry数组
Entry<K,V> e = src[j]; //取得旧Entry数组的每个元素
if (e != null) {
src[j] = null;//释放旧Entry数组的对象引用（for循环后，旧的Entry数组不再引用任何对象）
do {
Entry<K,V> next = e.next;
int i = indexFor(e.hash, newCapacity); //！！重新计算每个元素在数组中的位置
e.next = newTable[i]; //标记[1]
newTable[i] = e; //将元素放在数组上
e = next; //访问下一个Entry链上的元素
} while (e != null);
}
}
} 我们可以看到，transfer方法会遍历旧数组，对于每个数组元素，会遍历其中的每个节点，并重新计算其hash值，然后使用头插法将其插入到新的索引位置上。
假设现在size=2， 所以key = 3、7、5，扩容的过程如下。
我们发现一个有趣的现象，7、3都刚好移动了2位，刚好是扩容的大小，即2位，这里我们再结合二进制位来看下：
由于扩容直接加了1倍，因此相当于length-1原来的最右侧的0变为了1，因此大于length-1的值，同一的位置下的1也被释放，相当于在原位置+原容量的位置。
因此，我们在扩充HashMap的时候，不需要像JDK1.7的实现那样重新计算hash，只需要看看原来的hash值新增的那个bit是1还是0就好了，是0的话索引没变，是1的话索引变成“原索引+oldCap”
这个设计非常的巧妙，既省去了重新计算hash值的时间，而且同时，由于新增的1bit是0还是1可以认为是随机的，因此resize的过程，均匀的把之前的冲突的节点分散到新的bucket了。这一块就是JDK1.8新增的优化点。有一点注意区别，JDK1.7中rehash的时候，旧链表迁移新链表的时候，如果在新表的数组索引位置相同，则链表元素会倒置，但是从上图可以看出，JDK1.8不会倒置。
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
if (oldCap > 0) {
// 超过最大值就不再扩充了，任由其冲突
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
// 没超过最大值，就扩充为原来的2倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else { // zero initial threshold signifies using defaults
// 使用无参构造方法生成的HashMap在这里初始化table
// 在真正使用到的时候才初始化，避免了空间的浪费
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
// 计算新的resize上限
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
if (oldTab != null) {
// 把每个bucket都移动到新的buckets中
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
// 拆分红黑树
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
// 链表优化重hash的代码块
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
// 原索引
next = e.next;
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
// 原索引+oldCap
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
// 原索引放到bucket里
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
// 原索引+oldCap放到bucket里
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
} 从源码中我们看到，1.8中采用了尾插法来实现迁移。 
总结
以上两个例子向我们展示了JDK是如何使用位运算来优化原先复杂度较高的计算步骤。我们在平时的需求开发以及系统设计时也可以进行一定的参考，比如两数交换的功能，如果性能要求较高时，我们可采用如下办法实现来避免引入第三个变量作为中间值的传递。
x = x ^ y // （1）
y = x ^ y // （2）
x = x ^ y // （3）
扫一扫
992
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
