鸿蒙OS BitSet

BitSet

java.lang.Object

|—java.util.BitSet

public class BitSet
extends Object
implements Cloneable, Serializable

这个类实现了一个根据需要增长的位向量。 位集的每个组件都有一个布尔值。 BitSet 的位由非负整数索引。 可以检查、设置或清除各个索引位。 一个 BitSet 可用于通过逻辑 AND、逻辑异或和逻辑异或操作来修改另一个 BitSet 的内容。

默认情况下，集合中的所有位最初都具有值 false。

每个位集都有一个当前大小，即该位集当前使用的空间位数。 请注意，大小与位集的实现有关，因此它可能会随着实现而改变。 位集的长度与位集的逻辑长度相关，并且独立于实现来定义。

除非另有说明，否则将 null 参数传递给 BitSet 中的任何方法都将导致 NullPointerException。

如果没有外部同步，BitSet 对于多线程使用是不安全的。

构造函数摘要

方法总结

构造函数详细信息

BitSet

public BitSet()

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

BitSet

public BitSet(int nbits)

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

参数：

Throws:

方法详情

valueOf

public static BitSet valueOf(long[] longs)

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

更准确地说，对于所有 n < 64 * longs.length，BitSet.valueOf(longs).get(n) == ((longs[n/64] & (1L<<(n%64))) != 0)。

此方法等效于 BitSet.valueOf(LongBuffer.wrap(longs))。

参数：

返回:

包含长数组中所有位的 BitSet

valueOf

public static BitSet valueOf(LongBuffer lb)

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

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

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

参数：

返回:

包含指定范围内缓冲区中所有位的 BitSet

valueOf

public static BitSet valueOf(byte[] bytes)

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

更准确地说，对于所有 n < 8 * bytes.length，BitSet.valueOf(bytes).get(n) == ((bytes[n/8] & (1<<(n%8))) != 0)。

此方法等效于 BitSet.valueOf(ByteBuffer.wrap(bytes))。

参数：

返回:

包含字节数组中所有位的 BitSet

valueOf

public static BitSet valueOf(ByteBuffer bb)

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

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

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

参数：

返回:

包含指定范围内缓冲区中所有位的 BitSet

toByteArray

public 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

public 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。

返回:

一个长数组，包含此位集中所有位的小端表示

flip

public void flip(int bitIndex)

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

参数：

Throws:

flip

public void flip(int fromIndex, int toIndex)

将从指定的 fromIndex（包括）到指定的 toIndex（不包括）的每个位设置为其当前值的补码。

参数：

Throws:

set

public void set(int bitIndex)

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

参数：

Throws:

set

public void set(int bitIndex, boolean value)

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

参数：

Throws:

set

public void set(int fromIndex, int toIndex)

将指定 fromIndex（包括）到指定 toIndex（不包括）的位设置为 true。

参数：

Throws:

set

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

将指定的 fromIndex（包括）到指定的 toIndex（不包括）的位设置为指定的值。

参数：

Throws:

clear

public void clear(int bitIndex)

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

参数：

Throws:

clear

public void clear(int fromIndex, int toIndex)

将从指定的 fromIndex（包括）到指定的 toIndex（不包括）的位设置为 false。

参数：

Throws:

clear

public void clear()

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

get

public boolean get(int bitIndex)

返回具有指定索引的位的值。 如果当前在此 BitSet 中设置了索引为 bitIndex 的位，则该值为 true； 否则，结果为false。

参数：

返回:

具有指定索引的位的值

Throws:

get

public BitSet get(int fromIndex, int toIndex)

返回一个新的 BitSet，该 BitSet 由该 BitSet 中从 fromIndex（包括）到 toIndex（不包括）的位组成。

参数：

返回:

此 BitSet 范围内的新 BitSet

Throws:

nextSetBit

public int nextSetBit(int fromIndex)

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

要遍历 BitSet 中的真实位，请使用以下循环：

  for (int i = bs.nextSetBit(0); i >= 0; i = bs.nextSetBit(i+1)) {
     // operate on index i here
     if (i == Integer.MAX_VALUE) {
         break; // or (i+1) would overflow
     }
 }

参数:

返回:

下一个设置位的索引，如果没有这样的位，则为 -1

Throws:

nextClearBit

public int nextClearBit(int fromIndex)

返回在指定起始索引上或之后发生的设置为 false 的第一位的索引。

参数：

返回:

下一个 clear 位的索引

Throws:

previousSetBit

public int previousSetBit(int fromIndex)

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

要遍历 BitSet 中的真实位，请使用以下循环：

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

参数:

返回:

前一个设置位的索引，如果没有这样的位，则为 -1

Throws:

previousClearBit

public int previousClearBit(int fromIndex)

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

参数：

返回:

前一个清除位的索引，如果没有这样的位，则为 -1

Throws:

length

public int length()

返回此 BitSet 的“逻辑大小”：BitSet 中最高设置位的索引加一。 如果 BitSet 不包含设置位，则返回零。

返回:

此 BitSet 的逻辑大小

isEmpty

public boolean isEmpty()

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

返回:

指示此 BitSet 是否为空的布尔值

intersects

public boolean intersects(BitSet set)

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

参数：

返回:

布尔值，指示此 BitSet 是否与指定的 BitSet 相交

cardinality

public int cardinality()

返回此 BitSet 中设置为 true 的位数。

返回:

此 BitSet 中设置为 true 的位数

and

public void and(BitSet set)

执行此目标位集与参数位集的逻辑与。 修改此位集，以便当且仅当它最初都具有值 true 并且位集参数中的相应位也具有值 true 时，其中的每个位都具有值 true。

参数：

or

public void or(BitSet set)

使用位集参数执行此位集的逻辑或。 修改此位集，以便当且仅当它已经具有值 true 或位集参数中的相应位具有值 true 时，其中的位具有值 true。

参数：

xor

public void xor(BitSet set)

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

• 该位最初的值为真，而参数中的相应位的值为false。
• 该位最初的值为假，而参数中的相应位的值为true。

参数：

andNot

public void andNot(BitSet set)

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

参数：

hashCode

public 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);
 }

请注意，如果位集发生更改，哈希码也会更改。

覆盖：

类 Object 中的 hashCode

返回:

此位集的哈希码值

size

public int size()

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

返回:

当前在此位集中的位数

equals

public boolean equals(Object obj)

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

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

一定为true。 不比较两个位集的当前大小。

覆盖：

类 Object 中的等于

参数：

返回:

如果对象相同，则为 true； 否则为false

clone

public Object clone()

克隆此 BitSet 会生成一个与其相同的新 BitSet。 位集的克隆是另一个位集，它具有与该位集完全相同的位设置为true。

覆盖：

在类 Object 中克隆

返回:

该位集的克隆

toString

public String toString()

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

例子：

 BitSet drPepper = new BitSet();

现在 drPepper.toString() 返回“{}”。

 drPepper.set(2);

现在 drPepper.toString() 返回“{2}”。

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

现在 drPepper.toString() 返回“{2, 4, 10}”。

覆盖：

类 Object 中的 toString

返回:

此位集的字符串表示

stream

public IntStream stream()

返回此 BitSet 包含处于设置状态的位的索引流。 索引按从低到高的顺序返回。 流的大小是设置状态的位数，等于 cardinality() 方法返回的值。

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

返回:

表示集合索引的整数流