BitSet

BitSet

BitSet ()

创建一个新的位集。 所有位最初都是false 。

BitSet

BitSet (int nbits)

创建一个位集，其初始大小足以显式表示索引在0到nbits-1范围内的位。 所有位最初都是false 。

and

void and (BitSet set)

执行此目标位的设置与参数位设置的逻辑与 。 该位集被修改，使得其中的每个位的值都为true当且仅当它们最初具有值true并且位设置参数中的对应位也具有值true 。

andNot

void andNot (BitSet set)

清除此 BitSet的相应位在指定的 BitSet设置的所有位。

cardinality

int cardinality ()

返回此 BitSet设置为 true的 BitSet 。

clear

void clear (int fromIndex, 
                int toIndex)

将从指定的 fromIndex （含）到指定的 toIndex （独占）的位设置为 false 。

clear

void clear (int bitIndex)

将索引指定的位设置为 false 。

clear

void clear ()

将此BitSet中的所有位设置为 false 。

clone

Object clone ()

克隆这BitSet产生一个新的BitSet是等于它。 该位集合的克隆是另一个位集合，它与该位集合具有完全相同的位，设置为true 。

equals

boolean equals (Object obj)

将此对象与指定的对象进行比较。 结果是true当且仅当参数不是null并且是一个Bitset对象，该对象具有与此位集合设置为true完全相同的一组位。 也就是说，对于每个非负int索引k ，

((BitSet)obj).get(k) == this.get(k)

flip

void flip (int bitIndex)

将指定索引处的位设置为其当前值的补码。

flip

void flip (int fromIndex, 
                int toIndex)

将指定的每一位 fromIndex （含）到指定 toIndex （独家）为其当前值的补码。

get

boolean get (int bitIndex)

返回具有指定索引的位的值。 该值是true如果与索引的比特bitIndex在该当前设置BitSet ; 否则，结果是false 。

get

BitSet get (int fromIndex, 
                int toIndex)

返回由 BitSet从 fromIndex （含）至 toIndex （ fromIndex ）的位组成的新的 BitSet 。

hashCode

int hashCode ()

返回此位集的哈希码值。 散列码仅取决于此BitSet中设置的位。

散列码被定义为以下计算的结果：

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

intersects

boolean intersects (BitSet set)

如果指定的 BitSet任何位设置为 true ，并且在此 BitSet中也设置为 true ，则返回true。

isEmpty

boolean isEmpty ()

如果此 BitSet包含设置为 true位，则返回true。

length

int length ()

返回BitSet的“逻辑大小”： BitSet中最高设置位的BitSet加上1。 如果BitSet包含设定位，则返回零。

nextClearBit

int nextClearBit (int fromIndex)

返回在指定起始索引处或之后出现的第一个设置为 false位的索引。

nextSetBit

int nextSetBit (int fromIndex)

返回在指定起始索引处或之后出现的第一位设置为true索引。 如果不存在这样的位，则返回-1 。

遍历 true位在 BitSet ，使用以下循环：

 for (int i = bs.nextSetBit(0); i >= 0; i = bs.nextSetBit(i+1)) {
     // operate on index i here
 }

or

void or (BitSet set)

执行该位集与位集参数的逻辑或 。 该位集被修改，使得其中的一个位的值为true当且仅当它已经具有值true或位集合参数中的相应位具有值true 。

previousClearBit

int previousClearBit (int fromIndex)

返回在指定起始索引处或之前出现的最接近位的索引，该位设置为false 。 如果不存在这样的位，或者如果给出-1作为起始索引，则返回-1 。

previousSetBit

int previousSetBit (int fromIndex)

返回在指定起始索引处或之前出现的设置为true的最近位的索引。 如果不存在这样的位，或者如果给出-1作为起始索引，则返回-1 。

遍历 true位在 BitSet ，使用以下循环：

 for (int i = bs.length(); (i = bs.previousSetBit(i-1)) >= 0; ) {
     // operate on index i here
 }

set

void set (int fromIndex, 
                int toIndex, 
                boolean value)

将指定的位 fromIndex （含）到指定 toIndex （不包括）到指定的值。

set

void set (int fromIndex, 
                int toIndex)

将指定的位 fromIndex （含）到指定 toIndex （不包括）至 true 。

set

void set (int bitIndex)

将指定索引处的位设置为 true 。

set

void set (int bitIndex, 
                boolean value)

将指定索引处的位设置为指定值。

size

int size ()

返回此BitSet用于表示位值的实际使用的空间位数。 该集合中的最大元素是大小 - 第一个元素。

stream

IntStream stream ()

返回这个BitSet在设置状态中包含一个位的索引流。 指数从最低到最高依次返回。 流的大小是设置状态中的位数，等于cardinality()方法返回的值。

在执行终端流操作期间，该位设置必须保持不变。 否则，终端流操作的结果是未定义的。

toByteArray

byte[] toByteArray ()

返回包含此位集中所有位的新字节数组。

更确切地说，如果
byte[] bytes = s.toByteArray();
然后bytes.length == (s.length()+7)/8和
s.get(n) == ((bytes[n/8] & (1<<(n%8))) != 0)
全部为n < 8 * bytes.length 。

toLongArray

long[] toLongArray ()

返回包含此位集中所有位的新长数组。

更确切地说，如果
long[] longs = s.toLongArray();
然后longs.length == (s.length()+63)/64和
s.get(n) == ((longs[n/64] & (1L<<(n%64))) != 0)
全部为n < 64 * longs.length 。

toString

String toString ()

返回此位集的字符串表示形式。 对于此BitSet在设置状态中包含一位的每个索引，该索引的十进制表示形式都包含在结果中。 这些指数按从低到高的顺序排列，用“，”（逗号和空格）分隔，并用大括号包围，从而形成一组整数的通常数学符号。

例：

 BitSet drPepper = new BitSet();

 drPepper.set(2);

 drPepper.set(4);
 drPepper.set(10);

valueOf

BitSet valueOf (long[] longs)

返回包含给定长数组中所有位的新位集。

更确切地说，
BitSet.valueOf(longs).get(n) == ((longs[n/64] & (1L<<(n%64))) != 0)
全部为n < 64 * longs.length 。

该方法相当于 BitSet.valueOf(LongBuffer.wrap(longs)) 。

valueOf

BitSet valueOf (byte[] bytes)

返回包含给定字节数组中所有位的新位集。

更确切地说，
BitSet.valueOf(bytes).get(n) == ((bytes[n/8] & (1<<(n%8))) != 0)
全部为n < 8 * bytes.length 。

该方法相当于 BitSet.valueOf(ByteBuffer.wrap(bytes)) 。

valueOf

BitSet valueOf (ByteBuffer bb)

返回包含给定字节缓冲区中位置和极限之间所有位的新位集。

更确切地说，
BitSet.valueOf(bb).get(n) == ((bb.get(bb.position()+n/8) & (1<<(n%8))) != 0)
全部为n < 8 * bb.remaining() 。

该字节缓冲区不会被该方法修改，并且位集不保留对缓冲区的引用。

valueOf

BitSet valueOf (LongBuffer lb)

返回一个新的位集，其中包含位置和极限之间给定长缓冲区中的所有位。

更确切地说，
BitSet.valueOf(lb).get(n) == ((lb.get(lb.position()+n/64) & (1L<<(n%64))) != 0)
全部为n < 64 * lb.remaining() 。

长缓冲区不会被此方法修改，并且位集不保留对缓冲区的引用。

xor

void xor (BitSet set)

使用位设置参数执行该位设置的逻辑异或 。 该位集被修改，以便当且仅当以下语句之一成立时，其中的某一位具有值true ：

• The bit initially has the value true, and the corresponding bit in the argument has the value false.
• The bit initially has the value false, and the corresponding bit in the argument has the value true.