OpenJDK 源代码阅读之 BitSet

概要

• 类继承关系

java.lang.Object
    java.util.BitSet

• 定义

public class BitSet
extends Object
implements Cloneable, Serializable

• 要点

BitSet 类用来支持位操作，给它一个 size ，就会返回一个对象，代表 size 个位。可以完成“与或非”操作。

实现

试想一下，long 最多也就 64 位，假如我们想对 1000 位进行一些运算，要如何实现呢？这个类就告诉我们怎么用一个数组，去实现位操作。

• 数据

private long[] words;

内部使用 long 类型的数组来存储数据。

• 初始化

public BitSet(int nbits) {
    // nbits can't be negative; size 0 is OK
    if (nbits < 0)
        throw new NegativeArraySizeException("nbits < 0: " + nbits);

    initWords(nbits);
    sizeIsSticky = true;
}

private void initWords(int nbits) {
    words = new long[wordIndex(nbits-1) + 1];
}

private static int wordIndex(int bitIndex) {
    return bitIndex >> ADDRESS_BITS_PER_WORD;
}

初始化会根据的位数决定要申请多大的数组，long 类型是 64 位，所以你如果 nbits 是 1~64，你只需要一个长度为1的数组就好。

• 扩充策略

要是数组不够用了，就要进行扩充，下面的函数会根据申请的 long 元素个数，经过与当前元素个数2倍的比较进行扩充。

private void ensureCapacity(int wordsRequired) {
    if (words.length < wordsRequired) {
        // Allocate larger of doubled size or required size
        int request = Math.max(2 * words.length, wordsRequired);
        words = Arrays.copyOf(words, request);
        sizeIsSticky = false;
    }
}

• 位翻转

public void flip(int bitIndex) {
    if (bitIndex < 0)
        throw new IndexOutOfBoundsException("bitIndex < 0: " + bitIndex);

    int wordIndex = wordIndex(bitIndex);
    expandTo(wordIndex);

    words[wordIndex] ^= (1L << bitIndex);

    recalculateWordsInUse();
    checkInvariants();
}

先根据索引位置 bitIndex 计算出相应的位在数组哪个元素里，然后再将 1 左移 bitIndex 位后与此元素作异或运算。注意bitIndex 如果超过了 64 位，会又循环回来，比如 1L << 69 其实和 1L << 5 是一样的，只不过异或的时候，一个与words[1] 异或，一个与 words[0]。

类中还有其它位操作，比如置1,清0,只是和 flip 的位操作符不同。

还有一类是区间内翻转，这需要首先临到一个相应区间全为1的数字，再与 words 相应元素作运算。

public void flip(int fromIndex, int toIndex) {
    checkRange(fromIndex, toIndex);

    if (fromIndex == toIndex)
        return;

    int startWordIndex = wordIndex(fromIndex);
    int endWordIndex   = wordIndex(toIndex - 1);
    expandTo(endWordIndex);

    long firstWordMask = WORD_MASK << fromIndex;
    long lastWordMask  = WORD_MASK >>> -toIndex;
    if (startWordIndex == endWordIndex) {
        // Case 1: One word
        words[startWordIndex] ^= (firstWordMask & lastWordMask);
    } else {
        // Case 2: Multiple words
        // Handle first word
        words[startWordIndex] ^= firstWordMask;

        // Handle intermediate words, if any
        for (int i = startWordIndex+1; i < endWordIndex; i++)
            words[i] ^= WORD_MASK;

        // Handle last word
        words[endWordIndex] ^= lastWordMask;
    }

    recalculateWordsInUse();
    checkInvariants();
}

如果区间跨越多个数组元素，还需要把中间的数个数组元素内容全部翻转。

• AND 操作

public void and(BitSet set) {
    if (this == set)
        return;

    while (wordsInUse > set.wordsInUse)
        words[--wordsInUse] = 0;

    // Perform logical AND on words in common
    for (int i = 0; i < wordsInUse; i++)
        words[i] &= set.words[i];

    recalculateWordsInUse();
    checkInvariants();
}

从这个函数体会一下，两个 BitSet 对象之间的 AND 操作如何进行，其实就是对应的数组元素之间作 AND 操作就行。

• hashCode

public int hashCode() {
    long h = 1234;
    for (int i = wordsInUse; --i >= 0; )
        h ^= words[i] * (i + 1);

    return (int)((h >> 32) ^ h);
}

计算哈希值的操作，说实话，我是不太明白为什么这样算哈希值的，为什么这样能减少不同 BitSet 之间的碰撞呢？

剩下的东西我也不想分析了，总之，需要把握整体的思路，就是如何用一个数组去实现位操作，每次操作需要弄清楚，在数组的哪些元素上操作，与什么数字作位操作，做什么位操作。