sample/java.util.BitSet.txt

   1 *java.util.BitSet* *BitSet* This class implements a vector of bits that grows as
   2
   3 public class BitSet
   4   extends    |java.lang.Object|
   5   implements |java.lang.Cloneable|
   6              |java.io.Serializable|
   7
   8 |java.util.BitSet_Description|
   9 |java.util.BitSet_Fields|
  10 |java.util.BitSet_Constructors|
  11 |java.util.BitSet_Methods|
  12
  13 ================================================================================
  14
  15 *java.util.BitSet_Constructors*
  16 |java.util.BitSet()|Creates a new bit set.
  17 |java.util.BitSet(int)|Creates a bit set whose initial size is large enough to
  18
  19 *java.util.BitSet_Methods*
  20 |java.util.BitSet.and(BitSet)|Performs a logical AND of this target bit set wit
  21 |java.util.BitSet.andNot(BitSet)|Clears all of the bits in this BitSet whose co
  22 |java.util.BitSet.cardinality()|Returns the number of bits set to true in this
  23 |java.util.BitSet.clear()|Sets all of the bits in this BitSet to false.
  24 |java.util.BitSet.clear(int)|Sets the bit specified by the index to false.
  25 |java.util.BitSet.clear(int,int)|Sets the bits from the specified fromIndex(inc
  26 |java.util.BitSet.clone()|Cloning this BitSet produces a new BitSet   that is e
  27 |java.util.BitSet.equals(Object)|Compares this object against the specified obj
  28 |java.util.BitSet.flip(int)|Sets the bit at the specified index to the compleme
  29 |java.util.BitSet.flip(int,int)|Sets each bit from the specified fromIndex(incl
  30 |java.util.BitSet.get(int)|Returns the value of the bit with the specified inde
  31 |java.util.BitSet.get(int,int)|Returns a new BitSet composed of bits from this
  32 |java.util.BitSet.hashCode()|Returns a hash code value for this bit set.
  33 |java.util.BitSet.intersects(BitSet)|Returns true if the specified BitSet has a
  34 |java.util.BitSet.isEmpty()|Returns true if this BitSet contains no bits that a
  35 |java.util.BitSet.length()|Returns the "logical size" of this BitSet: the index
  36 |java.util.BitSet.nextClearBit(int)|Returns the index of the first bit that is
  37 |java.util.BitSet.nextSetBit(int)|Returns the index of the first bit that is se
  38 |java.util.BitSet.or(BitSet)|Performs a logical OR of this bit set with the bit
  39 |java.util.BitSet.set(int)|Sets the bit at the specified index to true.
  40 |java.util.BitSet.set(int,boolean)|Sets the bit at the specified index to the s
  41 |java.util.BitSet.set(int,int)|Sets the bits from the specified fromIndex(inclu
  42 |java.util.BitSet.set(int,int,boolean)|Sets the bits from the specified fromInd
  43 |java.util.BitSet.size()|Returns the number of bits of space actually in use by
  44 |java.util.BitSet.toString()|Returns a string representation of this bit set.
  45 |java.util.BitSet.xor(BitSet)|Performs a logical XOR of this bit set with the b
  46
  47 *java.util.BitSet_Description*
  48
  49 This class implements a vector of bits that grows as needed. Each component of
  50 the bit set has a boolean value. The bits of a BitSet are indexed by
  51 nonnegative integers. Individual indexed bits can be examined, set, or cleared.
  52 One BitSet may be used to modify the contents of another BitSet through logical
  53 AND, logical inclusive OR, and logical exclusive OR operations.
  54
  55 By default, all bits in the set initially have the value false.
  56
  57 Every bit set has a current size, which is the number of bits of space
  58 currently in use by the bit set. Note that the size is related to the
  59 implementation of a bit set, so it may change with implementation. The length
  60 of a bit set relates to logical length of a bit set and is defined
  61 independently of implementation.
  62
  63 Unless otherwise noted, passing a null parameter to any of the methods in a
  64 BitSet will result in a NullPointerException.
  65
  66 A BitSet is not safe for multithreaded use without external synchronization.
  67
  68
  69 *java.util.BitSet()*
  70
  71 public BitSet()
  72
  73 Creates a new bit set. All bits are initially false.
  74
  75
  76 *java.util.BitSet(int)*
  77
  78 public BitSet(int nbits)
  79
  80 Creates a bit set whose initial size is large enough to explicitly represent
  81 bits with indices in the range 0 through nbits-1. All bits are initially false.
  82
  83     nbits - the initial size of the bit set.
  84
  85 *java.util.BitSet.and(BitSet)*
  86
  87 public void and(java.util.BitSet set)
  88
  89 Performs a logical AND of this target bit set with the argument bit set. This
  90 bit set is modified so that each bit in it has the value true if and only if it
  91 both initially had the value true and the corresponding bit in the bit set
  92 argument also had the value true.
  93
  94     set - a bit set.
  95
  96 *java.util.BitSet.andNot(BitSet)*
  97
  98 public void andNot(java.util.BitSet set)
  99
 100 Clears all of the bits in this BitSet whose corresponding bit is set in the
 101 specified BitSet.
 102
 103     set - the BitSet with which to mask this BitSet.
 104
 105 *java.util.BitSet.cardinality()*
 106
 107 public int cardinality()
 108
 109 Returns the number of bits set to true in this BitSet.
 110
 111
 112     Returns: the number of bits set to true in this BitSet.
 113 *java.util.BitSet.clear()*
 114
 115 public void clear()
 116
 117 Sets all of the bits in this BitSet to false.
 118
 119
 120 *java.util.BitSet.clear(int)*
 121
 122 public void clear(int bitIndex)
 123
 124 Sets the bit specified by the index to false.
 125
 126     bitIndex - the index of the bit to be cleared.
 127
 128 *java.util.BitSet.clear(int,int)*
 129
 130 public void clear(
 131   int fromIndex,
 132   int toIndex)
 133
 134 Sets the bits from the specified fromIndex(inclusive) to the specified
 135 toIndex(exclusive) to false.
 136
 137     fromIndex - index of the first bit to be cleared.
 138     toIndex - index after the last bit to be cleared.
 139
 140 *java.util.BitSet.clone()*
 141
 142 public |java.lang.Object| clone()
 143
 144 Cloning this BitSet produces a new BitSet that is equal to it. The clone of the
 145 bit set is another bit set that has exactly the same bits set to true as this
 146 bit set and the same current size. Overrides the clone method of Object.
 147
 148
 149     Returns: a clone of this bit set.
 150 *java.util.BitSet.equals(Object)*
 151
 152 public boolean equals(java.lang.Object obj)
 153
 154 Compares this object against the specified object. The result is true if and
 155 only if the argument is not null and is a Bitset object that has exactly the
 156 same set of bits set to true as this bit set. That is, for every nonnegative
 157 int index k,
 158
 159 ((BitSet)obj).get(k) == this.get(k)
 160
 161 must be true. The current sizes of the two bit sets are not compared. Overrides
 162 the equals method of Object.
 163
 164     obj - the object to compare with.
 165
 166     Returns: true if the objects are the same; false otherwise.
 167 *java.util.BitSet.flip(int)*
 168
 169 public void flip(int bitIndex)
 170
 171 Sets the bit at the specified index to the complement of its current value.
 172
 173     bitIndex - the index of the bit to flip.
 174
 175 *java.util.BitSet.flip(int,int)*
 176
 177 public void flip(
 178   int fromIndex,
 179   int toIndex)
 180
 181 Sets each bit from the specified fromIndex(inclusive) to the specified
 182 toIndex(exclusive) to the complement of its current value.
 183
 184     fromIndex - index of the first bit to flip.
 185     toIndex - index after the last bit to flip.
 186
 187 *java.util.BitSet.get(int)*
 188
 189 public boolean get(int bitIndex)
 190
 191 Returns the value of the bit with the specified index. The value is true if the
 192 bit with the index bitIndex is currently set in this BitSet; otherwise, the
 193 result is false.
 194
 195     bitIndex - the bit index.
 196
 197     Returns: the value of the bit with the specified index.
 198 *java.util.BitSet.get(int,int)*
 199
 200 public |java.util.BitSet| get(
 201   int fromIndex,
 202   int toIndex)
 203
 204 Returns a new BitSet composed of bits from this BitSet from
 205 fromIndex(inclusive) to toIndex(exclusive).
 206
 207     fromIndex - index of the first bit to include.
 208     toIndex - index after the last bit to include.
 209
 210     Returns: a new BitSet from a range of this BitSet.
 211 *java.util.BitSet.hashCode()*
 212
 213 public int hashCode()
 214
 215 Returns a hash code value for this bit set. The has code depends only on which
 216 bits have been set within this BitSet. The algorithm used to compute it may be
 217 described as follows. Suppose the bits in the BitSet were to be stored in an
 218 array of long integers called, say, bits, in such a manner that bit k is set in
 219 the BitSet (for nonnegative values of k) if and only if the expression
 220
 221 ((k>>6) < bits.length) ((bits[k>>6] & (1L << (bit & 0x3F))) != 0)
 222
 223 is true. Then the following definition of the hashCode method would be a
 224 correct implementation of the actual algorithm:
 225
 226 public int hashCode() { long h = 1234; for (int i = bits.length; --i >= 0; ) {
 227 h ^= bits[i] * (i + 1); } return (int)((h >> 32) ^ h); }
 228
 229 Note that the hash code values change if the set of bits is altered. Overrides
 230 the hashCode method of Object.
 231
 232
 233     Returns: a hash code value for this bit set.
 234 *java.util.BitSet.intersects(BitSet)*
 235
 236 public boolean intersects(java.util.BitSet set)
 237
 238 Returns true if the specified BitSet has any bits set to true that are also set
 239 to true in this BitSet.
 240
 241     set - BitSet to intersect with
 242
 243     Returns: boolean indicating whether this BitSet intersects the specified BitSet.
 244 *java.util.BitSet.isEmpty()*
 245
 246 public boolean isEmpty()
 247
 248 Returns true if this BitSet contains no bits that are set to true.
 249
 250
 251     Returns: boolean indicating whether this BitSet is empty.
 252 *java.util.BitSet.length()*
 253
 254 public int length()
 255
 256 Returns the "logical size" of this BitSet: the index of the highest set bit in
 257 the BitSet plus one. Returns zero if the BitSet contains no set bits.
 258
 259
 260     Returns: the logical size of this BitSet.
 261 *java.util.BitSet.nextClearBit(int)*
 262
 263 public int nextClearBit(int fromIndex)
 264
 265 Returns the index of the first bit that is set to false that occurs on or after
 266 the specified starting index.
 267
 268     fromIndex - the index to start checking from (inclusive).
 269
 270     Returns: the index of the next clear bit.
 271 *java.util.BitSet.nextSetBit(int)*
 272
 273 public int nextSetBit(int fromIndex)
 274
 275 Returns the index of the first bit that is set to true that occurs on or after
 276 the specified starting index. If no such bit exists then -1 is returned.
 277
 278 To iterate over the true bits in a BitSet, use the following loop:
 279
 280 for(int i=bs.nextSetBit(0); i>=0; i=bs.nextSetBit(i+1)) { // operate on index i
 281 here }
 282
 283     fromIndex - the index to start checking from (inclusive).
 284
 285     Returns: the index of the next set bit.
 286 *java.util.BitSet.or(BitSet)*
 287
 288 public void or(java.util.BitSet set)
 289
 290 Performs a logical OR of this bit set with the bit set argument. This bit set
 291 is modified so that a bit in it has the value true if and only if it either
 292 already had the value true or the corresponding bit in the bit set argument has
 293 the value true.
 294
 295     set - a bit set.
 296
 297 *java.util.BitSet.set(int)*
 298
 299 public void set(int bitIndex)
 300
 301 Sets the bit at the specified index to true.
 302
 303     bitIndex - a bit index.
 304
 305 *java.util.BitSet.set(int,boolean)*
 306
 307 public void set(
 308   int bitIndex,
 309   boolean value)
 310
 311 Sets the bit at the specified index to the specified value.
 312
 313     bitIndex - a bit index.
 314     value - a boolean value to set.
 315
 316 *java.util.BitSet.set(int,int)*
 317
 318 public void set(
 319   int fromIndex,
 320   int toIndex)
 321
 322 Sets the bits from the specified fromIndex(inclusive) to the specified
 323 toIndex(exclusive) to true.
 324
 325     fromIndex - index of the first bit to be set.
 326     toIndex - index after the last bit to be set.
 327
 328 *java.util.BitSet.set(int,int,boolean)*
 329
 330 public void set(
 331   int fromIndex,
 332   int toIndex,
 333   boolean value)
 334
 335 Sets the bits from the specified fromIndex(inclusive) to the specified
 336 toIndex(exclusive) to the specified value.
 337
 338     fromIndex - index of the first bit to be set.
 339     toIndex - index after the last bit to be set
 340     value - value to set the selected bits to
 341
 342 *java.util.BitSet.size()*
 343
 344 public int size()
 345
 346 Returns the number of bits of space actually in use by this BitSet to represent
 347 bit values. The maximum element in the set is the size - 1st element.
 348
 349
 350     Returns: the number of bits currently in this bit set.
 351 *java.util.BitSet.toString()*
 352
 353 public |java.lang.String| toString()
 354
 355 Returns a string representation of this bit set. For every index for which this
 356 BitSet contains a bit in the set state, the decimal representation of that
 357 index is included in the result. Such indices are listed in order from lowest
 358 to highest, separated by "," (a comma and a space) and surrounded by braces,
 359 resulting in the usual mathematical notation for a set of integers. Overrides
 360 the toString method of Object. Example:
 361
 362 BitSet drPepper = new BitSet();
 363
 364 Now drPepper.toString() returns "{}".
 365
 366 drPepper.set(2);
 367
 368 Now drPepper.toString() returns "{2}".
 369
 370 drPepper.set(4); drPepper.set(10);
 371
 372 Now drPepper.toString() returns "{2, 4, 10}".
 373
 374
 375     Returns: a string representation of this bit set.
 376 *java.util.BitSet.xor(BitSet)*
 377
 378 public void xor(java.util.BitSet set)
 379
 380 Performs a logical XOR of this bit set with the bit set argument. This bit set
 381 is modified so that a bit in it has the value true if and only if one of the
 382 following statements holds:
 383
 384 The bit initially has the value true, and the corresponding bit in the argument
 385 has the value false. The bit initially has the value false, and the
 386 corresponding bit in the argument has the value true.
 387
 388     set - a bit set.
 389
 390