BitSet源码

public class BitSet1 implements Cloneable, java.io.Serializable {
    // >>>左边补0， <<  右边补0。
    public final static int ADDRESS_BITS_PER_WORD = 6;
    public final static int BITS_PER_WORD = 1 << ADDRESS_BITS_PER_WORD;//2^6=64
    public final static int BIT_INDEX_MASK = BITS_PER_WORD - 1;//
    public static final long WORD_MASK = 0xffffffffffffffffL;//16进制64bit,全1，就是-1

    //序列化字段，第i位存储在位位置i%64的位[i/64]中
    public static final ObjectStreamField[] serialPersistentFields = {
        new ObjectStreamField("bits", long[].class),
    };

    public long[] words;//long数组来作为内部存储结构。Bitset至少为一个long的大小

    //数组长度
    public transient int wordsInUse = 0;//使用的words数组，小于等于words.length。wordsInUse-1是不为0的long的最大位置。一直到words.length可以等于0。

    //“words”的大小是否由用户指定。
    public transient boolean sizeIsSticky = false;

    public static final long serialVersionUID = 7997698588986878753L;

    public static int wordIndex(int bitIndex) {
        return bitIndex >> ADDRESS_BITS_PER_WORD;//除以64，右移6位，取整。
        //1-6位全部移出去，第6位=32移出去了变成了0。第7位=64变成第一位=1，第8位=128变成第二位=2。从第7位到32位全部除以64，不要余数取整。
    }

    //wordsInUse >= 0 , wordsInUse <= words.length , words[wordsInUse - 1] != 0 , words[wordsInUse] == 0
    public void checkInvariants() {
        //左边走了，右边就不走了。
        assert(wordsInUse >= 0 && wordsInUse <= words.length);
        assert(wordsInUse == 0 || words[wordsInUse - 1] != 0);
        //wordsInUse等于0可以，就不走右边了。不等于0那么words[wordsInUse - 1]就不能为0。wordsInUse-1是不为0的long的最大位置。
        assert(wordsInUse == words.length || words[wordsInUse] == 0);
        //wordsInUse == words.length可以就不走右边了。如果2者不相等wordsInUse要小，words[wordsInUse]就要等于0。words[wordsInUse - 1]就不能为0。
    }

    //清除为0的，减少内存。
    public void recalculateWordsInUse() {
        int i;
        for (i = wordsInUse-1; i >= 0; i--)
            if (words[i] != 0)
                break;
        wordsInUse = i+1; // 从后往前找，第一个非0的后面一个元素
    }

    public BitSet1() {
        initWords(BITS_PER_WORD);//64长度，words数组只有1个长度。
        sizeIsSticky = false;//为false表示使用的是默认大小
    }

    public BitSet1(int nbits) {
        if (nbits < 0)
            throw new NegativeArraySizeException("nbits < 0: " + nbits);
        initWords(nbits);//传进来的是bit位的位数
        sizeIsSticky = true;//为true表示大小是传进来的
    }

    public void initWords(int nbits) {//nbits是总位数，一个long是64位。
        words = new long[wordIndex(nbits-1) + 1];//wordIndex是取整
    }

    public BitSet1(long[] words) {
        this.words = words;//[113, 289, 8481]
        this.wordsInUse = words.length;//>=0,3
        checkInvariants();
    }

    //BitSet.valueOf(longs).get(n) == ((longs[n/64] & (1L<<(n%64))) != 0) for all n < 64 * longs.length .
    public static BitSet1 valueOf(long[] longs) {
        int n;//都要先除去0的元素，节约内存。
        for (n = longs.length; n > 0 && longs[n - 1] == 0; n--);//n-1是longs数组最后一个不为0的索引位置，n就是个数。
        return new BitSet1(Arrays.copyOf(longs, n));//拷贝longs前n个元素或者longs数组长度个元素，取2者较小者。
    }

    //把lb中真实元素（position到limit），并且去除多余的0，然后给bitset。
    public static BitSet1 valueOf(LongBuffer1 lb) {//LongBuffer是提供对long[]数组操作。对于读取到的long[]做一些增删改查后再使用，就是缓冲区。
        //mark=-1,pos=0,lim=limit-position,cap=limit-position,offset=position。 slice()得到的是原来position到limit的位置的数据，包括position不包括limit。所有元素相对原来数组的相对值是offset，
        //从0开始一直到remaining()。
        lb = lb.slice();
        int n;
        //确定最后一个不为0的数据的个数。都要先除去0的元素，节约内存。
        //slice()之后的put和set都会加上offset=pisition，就是获取原数组的position到limit的所有位置元素，不包括limit。
        for (n = lb.remaining(); n > 0 && lb.get(n - 1) == 0; n--);//从0开始一直到remaining()，除去后面为0的。
        long[] words = new long[n];//n是不为0的位置个数，包括开头一共n个，
        lb.get(words);//把lb的值全部复制到words里面去。
        return new BitSet1(words);
    }

    public static BitSet1 valueOf(byte[] bytes) {
        return BitSet1.valueOf(ByteBuffer.wrap(bytes));
    }

    //把bb中真实元素（position到limit），并且去除多余的0，然后给bitset。
    public static BitSet1 valueOf(ByteBuffer bb) {
        bb = bb.slice().order(ByteOrder.LITTLE_ENDIAN);//slice()之后，所有元素相对原来数组的相对值是offset，从0到remaining。
        int n;
        for (n = bb.remaining(); n > 0 && bb.get(n - 1) == 0; n--);//除去0重新计算n = position到limit除去0之后元素个数。
        long[] words = new long[(n + 7) / 8];//取整加1
        bb.limit(n);//bb的limit之前等于remainnig，现在为n。
        int i = 0;
        while (bb.remaining() >= 8)
            words[i++] = bb.getLong();//position移动8位，
        for (int remaining = bb.remaining(), j = 0; j < remaining; j++)
            words[i] |= (bb.get() & 0xffL) << (8 * j);//0xffL:前面全0，后面一个字节8个1。移8n位再或。
        return new BitSet1(words);
    }

    /*
     byte[] bytes = s.toByteArray();
     bytes.length == (s.length()+7)/8 and s.get(n) == ((bytes[n/8] & (1<<(n%8))) != 0)：实例画图。
    */
    public byte[] toByteArray() {//bit是从long数组低位开始放，一直放到最高位，最高位是从低位开始放。
        int n = wordsInUse;
        if (n == 0)
            return new byte[0];
        int len = 8 * (n-1);
        for (long x = words[n - 1]; x != 0; x >>>= 8)//最后一个的值，一直除以256，
            len++;
        byte[] bytes = new byte[len];
        ByteBuffer bb = ByteBuffer.wrap(bytes).order(ByteOrder.LITTLE_ENDIAN);
        for (int i = 0; i < n - 1; i++)
            bb.putLong(words[i]);
        for (long x = words[n - 1]; x != 0; x >>>= 8)
            bb.put((byte) (x & 0xff));
        return bytes;
    }

    public long[] toLongArray() {
        return Arrays.copyOf(words, wordsInUse);
    }

    public void ensureCapacity(int wordsRequired) {
        if (words.length < wordsRequired) {
            int request = Math.max(2 * words.length, wordsRequired);
            words = Arrays.copyOf(words, request);//长度还是request个长度，只是复制 Math.min(words.length, request)元素过去。
            sizeIsSticky = false;
        }
    }

    public void expandTo(int wordIndex) {
        int wordsRequired = wordIndex+1;
        if (wordsInUse < wordsRequired) {
            ensureCapacity(wordsRequired);
            wordsInUse = wordsRequired;
        }
    }

    public static void checkRange(int fromIndex, int toIndex) {
        if (fromIndex < 0)
            throw new IndexOutOfBoundsException("fromIndex < 0: " + fromIndex);
        if (toIndex < 0)
            throw new IndexOutOfBoundsException("toIndex < 0: " + toIndex);
        if (fromIndex > toIndex)
            throw new IndexOutOfBoundsException("fromIndex: " + fromIndex + " > toIndex: " + toIndex);
    }

    public void flip(int bitIndex) {//65，指定位反转。
        if (bitIndex < 0)
            throw new IndexOutOfBoundsException("bitIndex < 0: " + bitIndex);
        int wordIndex = wordIndex(bitIndex);//
        expandTo(wordIndex);
        words[wordIndex] ^= (1L << bitIndex);//移动位数对64取模，异或就是其余位置不变，这个位置取反。
        recalculateWordsInUse();
        checkInvariants();
    }

    public void flip(int fromIndex, int toIndex) {
        checkRange(fromIndex, toIndex);
        if (fromIndex == toIndex)
            return;
        int startWordIndex = wordIndex(fromIndex);//开始数组索引
        int endWordIndex   = wordIndex(toIndex - 1);//结束数组索引，要减1。
        expandTo(endWordIndex);
        //fromIndex对64取模位置开始(包括这个位置)一直到最前面都是1，后面都是0。
        long firstWordMask = WORD_MASK << fromIndex;//用于异或的值
        //>>>左边补上0，左边是0右边是1。右移64-toIndex%64
        //6>>>-2相当于6>>>30,(32+(-2))==30。
        long lastWordMask  = WORD_MASK >>> -toIndex;//无符号右移，忽略了符号位扩展，0补左边。用于异或的值
        if (startWordIndex == endWordIndex) {
            // 一个数组里面异或
            words[startWordIndex] ^= (firstWordMask & lastWordMask);//对1异或，就是取反。
        } else {
            // 开始数组异或
            words[startWordIndex] ^= firstWordMask;
            // 中间数组异或
            for (int i = startWordIndex+1; i < endWordIndex; i++)
                words[i] ^= WORD_MASK;
            // 结尾数组异或
            words[endWordIndex] ^= lastWordMask;
        }
        recalculateWordsInUse();
        checkInvariants();
    }

    public void set(int bitIndex) {//设置bit位为1
        if (bitIndex < 0)
            throw new IndexOutOfBoundsException("bitIndex < 0: " + bitIndex);
        int wordIndex = wordIndex(bitIndex);
        expandTo(wordIndex);
        words[wordIndex] |= (1L << bitIndex);
        checkInvariants();
    }

    public void set(int bitIndex, boolean value) {
        if (value)
            set(bitIndex);
        else
            clear(bitIndex);
    }

    public void set(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) {
            words[startWordIndex] |= (firstWordMask & lastWordMask);//0变成1，1变成1，就是全设置为1。
        } else {
            words[startWordIndex] |= firstWordMask;//或操作就是设置为1，
            for (int i = startWordIndex+1; i < endWordIndex; i++)
                words[i] = WORD_MASK;
            words[endWordIndex] |= lastWordMask;
        }
        checkInvariants();
    }

    public void set(int fromIndex, int toIndex, boolean value) {
        if (value)
            set(fromIndex, toIndex);
        else
            clear(fromIndex, toIndex);
    }

    public void clear(int bitIndex) {
        if (bitIndex < 0)
            throw new IndexOutOfBoundsException("bitIndex < 0: " + bitIndex);
        int wordIndex = wordIndex(bitIndex);
        if (wordIndex >= wordsInUse)
            return;
        words[wordIndex] &= ~(1L << bitIndex);//指定位变为0，&是与操作，1L<<n是只有1位的long值。
        recalculateWordsInUse();
        checkInvariants();
    }

    public void clear(int fromIndex, int toIndex) {
        checkRange(fromIndex, toIndex);
        if (fromIndex == toIndex)
            return;
        int startWordIndex = wordIndex(fromIndex);
        if (startWordIndex >= wordsInUse)
            return;
        int endWordIndex = wordIndex(toIndex - 1);
        if (endWordIndex >= wordsInUse) {
            toIndex = length();
            endWordIndex = wordsInUse - 1;
        }
        long firstWordMask = WORD_MASK << fromIndex;
        long lastWordMask  = WORD_MASK >>> -toIndex;
        if (startWordIndex == endWordIndex) {
            words[startWordIndex] &= ~(firstWordMask & lastWordMask);//
        } else {
            words[startWordIndex] &= ~firstWordMask;
            for (int i = startWordIndex+1; i < endWordIndex; i++)
                words[i] = 0;
            words[endWordIndex] &= ~lastWordMask;
        }
        recalculateWordsInUse();
        checkInvariants();
    }

    public void clear() {
        while (wordsInUse > 0)
            words[--wordsInUse] = 0;//全部清0
    }

    public boolean get(int bitIndex) {//返回的0,1就是true,false。
        if (bitIndex < 0)
            throw new IndexOutOfBoundsException("bitIndex < 0: " + bitIndex);
        checkInvariants();
        int wordIndex = wordIndex(bitIndex);
        //通过与操作得到一个long的值，来判断某一位是0还是1。
        //&就能按位操作
        //1L << bitIndex就能得到移位后的long值
        return (wordIndex < wordsInUse) && ((words[wordIndex] & (1L << bitIndex)) != 0);
    }

    public BitSet1 get(int fromIndex, int toIndex) {//包头不包尾，获取指定区间的bitset，返回的也是long[]数组装着。
        checkRange(fromIndex, toIndex);
        checkInvariants();
        int len = length();//总共多少bit位
        if (len <= fromIndex || fromIndex == toIndex)
            return new BitSet1(0);
        if (toIndex > len)
            toIndex = len;
        BitSet1 result = new BitSet1(toIndex - fromIndex);//bit的长度
        //toIndex - fromIndex:::0-64:1,65-128:2,129-192:3。
        int targetWords = wordIndex(toIndex - fromIndex - 1) + 1;//数组个数
        int sourceIndex = wordIndex(fromIndex);//开始数组索引
        //对64取余为0，开始位置就是64的整数倍0,64,128,192。
        boolean wordAligned = ((fromIndex & BIT_INDEX_MASK) == 0);

        //除了最后一个word。为数组前n-1个元素赋值
        for (int i = 0; i < targetWords - 1; i++, sourceIndex++)
            result.words[i] = wordAligned ? words[sourceIndex] : //开始位置是64整数倍，整个long拿出去
                (words[sourceIndex] >>> fromIndex) | (words[sourceIndex+1] << -fromIndex);//数组相邻位置凑成64个。从左边fromIndex位置到右边fromIndex位置取出64个来成为一个long，包括左边fromIndex不包括右边fromIndex。
            //一直到最后一个的fromIndex的位置（最后一个fromIndex还没有取出去），并且最后一个的fromIndex到toIndex构成不了64个。

        long lastWordMask = WORD_MASK >>> -toIndex; //WORD_MASK = 0xffffffffffffffffL。toIndex右边都是1（不包括toIndex）。
        result.words[targetWords - 1] =
                //64取余，一个数组里面谁在左边右边。
                //toIndex-1 < fromIndex，fromIndex取余后要大，由于是反的，fromIndex在左边toIndex-1在右边。所以有2个long元素综合起来。
            ((toIndex-1) & BIT_INDEX_MASK) < (fromIndex & BIT_INDEX_MASK)//BIT_INDEX_MASK=63。
            ?
            ((words[sourceIndex] >>> fromIndex) | //最后一个没有取完的，
                    (words[sourceIndex+1] & lastWordMask) << -fromIndex)//加上toIndex右边的，
            :
            ((words[sourceIndex] & lastWordMask) >>> fromIndex);//toIndex-1 > fromIndex，toIndex在左边，

        result.wordsInUse = targetWords;
        result.recalculateWordsInUse();
        result.checkInvariants();

        return result;
    }

    public int nextSetBit(int fromIndex) {//从fromIndex开始第一个1在哪个位置（包括fromIndex），返回的位置是索引，
        if (fromIndex < 0)
            throw new IndexOutOfBoundsException("fromIndex < 0: " + fromIndex);
        checkInvariants();
        int u = wordIndex(fromIndex);
        if (u >= wordsInUse)
            return -1;
        long word = words[u] & (WORD_MASK << fromIndex);//words[u]左边fromIndex（取模）开始为1（包括fromIndex位置）。fromIndex右边要置为0。
        System.out.println(Long.toBinaryString(word));
        System.out.println(Long.toBinaryString(WORD_MASK << fromIndex));
        while (true) {
            if (word != 0) {//等于0就全是0，
                System.out.println(Long.numberOfTrailingZeros(word));
                return (u * BITS_PER_WORD) + Long.numberOfTrailingZeros(word);//numberOfTrailingZeros右边有多少个0，
            }
            if (++u == wordsInUse)//u加1一直到wordsInUse-1，就退出
                return -1;
            word = words[u];//修改word的值，不移位了。
        }
    }

    public int nextClearBit(int fromIndex) {//从fromIndex开始第一个为0的位置，包括fromIndex。返回的位置是索引，
        if (fromIndex < 0)
            throw new IndexOutOfBoundsException("fromIndex < 0: " + fromIndex);
        checkInvariants();
        int u = wordIndex(fromIndex);
        if (u >= wordsInUse)
            return fromIndex;

        long word = ~words[u] & (WORD_MASK << fromIndex);

        while (true) {
            if (word != 0)
                return (u * BITS_PER_WORD) + Long.numberOfTrailingZeros(word);//numberOfTrailingZeros右边有多少个0，
            //word全1就++，
            if (++u == wordsInUse)
                return wordsInUse * BITS_PER_WORD;
            word = ~words[u];
        }
    }

    public int previousSetBit(int fromIndex) {//从fromIndex开始（包括fromIndex）前面第一个1,
        if (fromIndex < 0) {
            if (fromIndex == -1)
                return -1;
            throw new IndexOutOfBoundsException("fromIndex < -1: " + fromIndex);
        }
        checkInvariants();
        int u = wordIndex(fromIndex);
        if (u >= wordsInUse)
            return length() - 1;
        long word = words[u] & (WORD_MASK >>> -(fromIndex+1));//fromIndex到右都是1，包括fromIndex，
        while (true) {
            if (word != 0)
                return (u+1) * BITS_PER_WORD - 1 - Long.numberOfLeadingZeros(word);//左边有多少个0
            if (u-- == 0)
                return -1;
            word = words[u];
        }
    }

    public int previousClearBit(int fromIndex) {
        if (fromIndex < 0) {
            if (fromIndex == -1)
                return -1;
            throw new IndexOutOfBoundsException("fromIndex < -1: " + fromIndex);
        }
        checkInvariants();
        int u = wordIndex(fromIndex);
        if (u >= wordsInUse)
            return fromIndex;
        long word = ~words[u] & (WORD_MASK >>> -(fromIndex+1));
        while (true) {
            if (word != 0)
                return (u+1) * BITS_PER_WORD -1 - Long.numberOfLeadingZeros(word);
            if (u-- == 0)
                return -1;
            word = ~words[u];
        }
    }

    public int length() {
        if (wordsInUse == 0)
            return 0;
        return BITS_PER_WORD * (wordsInUse - 1) +  //前面64*(length-1)个位的个数
            //numberOfLeadingZeros()一个long值里面左边有多少个0，
            (BITS_PER_WORD - Long.numberOfLeadingZeros(words[wordsInUse - 1]));
    }

    public boolean isEmpty() {
        return wordsInUse == 0;
    }

    public boolean intersects(BitSet1 set) {
        for (int i = Math.min(wordsInUse, set.wordsInUse) - 1; i >= 0; i--)
            if ((words[i] & set.words[i]) != 0)//&是位操作，等于0就继续，等于0就是没有1跟1相对的。
                return true;
        return false;
    }

    public int cardinality() {
        int sum = 0;
        for (int i = 0; i < wordsInUse; i++)
            sum += Long.bitCount(words[i]);//为1的个数
        return sum;
    }

    public void and(BitSet1 set) {
        if (this == set)
            return;
        while (wordsInUse > set.wordsInUse)
            words[--wordsInUse] = 0;
        for (int i = 0; i < wordsInUse; i++)
            words[i] &= set.words[i];//逻辑与操作
        recalculateWordsInUse();
        checkInvariants();
    }

    public void or(BitSet1 set) {//逻辑或操作
        if (this == set)
            return;
        int wordsInCommon = Math.min(wordsInUse, set.wordsInUse);
        if (wordsInUse < set.wordsInUse) {
            ensureCapacity(set.wordsInUse);
            wordsInUse = set.wordsInUse;
        }
        for (int i = 0; i < wordsInCommon; i++)
            words[i] |= set.words[i];
        if (wordsInCommon < set.wordsInUse)
            System.arraycopy(set.words, wordsInCommon, words, wordsInCommon, wordsInUse - wordsInCommon);
        checkInvariants();
    }

    public void xor(BitSet1 set) {
        int wordsInCommon = Math.min(wordsInUse, set.wordsInUse);
        if (wordsInUse < set.wordsInUse) {
            ensureCapacity(set.wordsInUse);
            wordsInUse = set.wordsInUse;
        }
        for (int i = 0; i < wordsInCommon; i++)
            words[i] ^= set.words[i];
        if (wordsInCommon < set.wordsInUse)
            System.arraycopy(set.words, wordsInCommon, words, wordsInCommon, set.wordsInUse - wordsInCommon);

        recalculateWordsInUse();
        checkInvariants();
    }

    public void andNot(BitSet1 set) {// Perform logical (a & !b) on words in common
        for (int i = Math.min(wordsInUse, set.wordsInUse) - 1; i >= 0; i--)
            words[i] &= ~set.words[i];
        recalculateWordsInUse();
        checkInvariants();
    }

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

    public int size() {
        return words.length * BITS_PER_WORD;
    }

    public boolean equals(Object obj) {
        if (!(obj instanceof BitSet1))
            return false;
        if (this == obj)
            return true;
        BitSet1 set = (BitSet1) obj;
        checkInvariants();
        set.checkInvariants();
        if (wordsInUse != set.wordsInUse)
            return false;
        for (int i = 0; i < wordsInUse; i++)
            if (words[i] != set.words[i])
                return false;
        return true;
    }

    public Object clone() {
        if (! sizeIsSticky)
            trimToSize();
        try {
            BitSet1 result = (BitSet1) super.clone();
            result.words = words.clone();
            result.checkInvariants();
            return result;
        } catch (CloneNotSupportedException e) {
            throw new InternalError(e);
        }
    }

    public void trimToSize() {
        if (wordsInUse != words.length) {
            words = Arrays.copyOf(words, wordsInUse);//只要wordsInUse和words.length较小者
            checkInvariants();
        }
    }

    public void writeObject(ObjectOutputStream s) throws IOException {
        checkInvariants();
        if (! sizeIsSticky)
            trimToSize();
        ObjectOutputStream.PutField fields = s.putFields();
        fields.put("bits", words);
        s.writeFields();
    }

    public void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException {
        ObjectInputStream.GetField fields = s.readFields();
        words = (long[]) fields.get("bits", null);
        // Assume maximum length then find real length
        // because recalculateWordsInUse assumes maintenance
        // or reduction in logical size
        wordsInUse = words.length;
        recalculateWordsInUse();
        sizeIsSticky = (words.length > 0 && words[words.length-1] == 0L); // heuristic
        checkInvariants();
    }

    public String toString() {//所有的1的索引位置，{0, 4, 5, 6, 64, 69, 72, 128, 133, 136, 141}
        checkInvariants();
        //大于128就看1的个数，小于就看所有个数
        int numBits = (wordsInUse > 128) ? cardinality() : wordsInUse * BITS_PER_WORD;
        StringBuilder b = new StringBuilder(6*numBits + 2);//
        b.append('{');
        int i = nextSetBit(0);//从0开始的第一个1在哪个位置，
        System.out.println("i1="+i);
        if (i != -1) {
            b.append(i);//i是所有的1的索引位置，
            System.out.println("b="+b);
            while (true) {
                if (++i < 0) break;//超过int最大值，前面i已经加过一次了，这里直接加加，
                if ((i = nextSetBit(i)) < 0) break;//从i+1开始，下一个为1的位置在哪里，
                int endOfRun = nextClearBit(i);//这里的i是还没有加进去的1的位置，
                System.out.println("endOfRun="+endOfRun);//从还没有加进去的i的位置开始，0的位置。
                System.out.println("i2="+i);
                do {
                    b.append(", ").append(i); //把这个i放入string里面，然后下面在加加，
                    System.out.println("b="+b);//中间全是1都加进去到b，
                }while (++i != endOfRun);//跳出时候i是0的位置endOfRun，所以出去后要加1，

            }
        }
        b.append('}');
        return b.toString();
    }

    /**
     * Returns a stream of indices for which this BitSet
     * contains a bit in the set state. The indices are returned
     * in order, from lowest to highest. The size of the stream
     * is the number of bits in the set state, equal to the value
     * returned by the {@link #cardinality()} method.
     *
     * <p>The bit set must remain constant during the execution of the
     * terminal stream operation.  Otherwise, the result of the terminal
     * stream operation is undefined.
     */
    public IntStream stream() {
        class BitSetIterator implements PrimitiveIterator.OfInt {
            int next = nextSetBit(0);//从0开始的第一个1的位置，
            @Override
            public boolean hasNext() {
                return next != -1;
            }
            @Override
            public int nextInt() {
                if (next != -1) {
                    int ret = next;
                    next = nextSetBit(next+1);//下一个1的位置
                    return ret;
                } else {
                    throw new NoSuchElementException();
                }
            }
        }

        return StreamSupport.intStream(
                //spliterator返回IntIteratorSpliterator分组器
                () -> Spliterators.spliterator(new BitSetIterator(), cardinality(),Spliterator.ORDERED | Spliterator.DISTINCT | Spliterator.SORTED),
                Spliterator.SIZED | Spliterator.SUBSIZED |Spliterator.ORDERED | Spliterator.DISTINCT | Spliterator.SORTED,false);
    }
}