Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| J2ME Foundation
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: INNER | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## java.util
Class BitSet

    java.lang.Object
      |
      +--java.util.BitSet

All Implemented Interfaces:
  Cloneable, Serializable

public class BitSet
extends Object
implements Cloneable, Serializable

This class implements a vector of bits that grows as needed. Each component of the bit set has a `boolean` value. The bits of a `BitSet` are indexed by nonnegative integers. Individual indexed bits can be examined, set, or cleared. One `BitSet` may be used to modify the contents of another `BitSet` through logical AND, logical inclusive OR, and logical exclusive OR operations.

By default, all bits in the set initially have the value `false`.

Every bit set has a current size, which is the number of bits of space currently in use by the bit set. Note that the size is related to the implementation of a bit set, so it may change with implementation. The length of a bit set relates to logical length of a bit set and is defined independently of implementation.

Since:
  JDK1.0
See Also:
  Serialized Form

Constructor Summary
`BitSet()` Creates a new bit set.
`BitSet(int nbits)` Creates a bit set whose initial size is large enough to explicitly represent bits with indices in the range `0` through `nbits-1`.

Method Summary
`void` | `and(BitSet set)` Performs a logical AND of this target bit set with the argument bit set.
`void` | `andNot(BitSet set)` Clears all of the bits in this `BitSet` whose corresponding bit is set in the specified `BitSet`.
`void` | `clear(int bitIndex)` Sets the bit specified by the index to `false`.
`Object` | `clone()` Cloning this `BitSet` produces a new `BitSet` that is equal to it.
`boolean` | `equals(Object obj)` Compares this object against the specified object.
`boolean` | `get(int bitIndex)` Returns the value of the bit with the specified index.
`int` | `hashCode()` Returns a hash code value for this bit set.
`int` | `length()` Returns the "logical size" of this `BitSet`: the index of the highest set bit in the `BitSet` plus one.
`void` | `or(BitSet set)` Performs a logical OR of this bit set with the bit set argument.
`void` | `set(int bitIndex)` Sets the bit specified by the index to `true`.
`int` | `size()` Returns the number of bits of space actually in use by this `BitSet` to represent bit values.
`String` | `toString()` Returns a string representation of this bit set.
`void` | `xor(BitSet set)` Performs a logical XOR of this bit set with the bit set argument.

Methods inherited from class java.lang.Object
`finalize, getClass, notify, notifyAll, wait, wait, wait`

Constructor Detail

### BitSet

    public BitSet()

  Creates a new bit set. All bits are initially `false`.

### BitSet

    public BitSet(int nbits)

  Creates a bit set whose initial size is large enough to explicitly represent bits with indices in the range `0` through `nbits-1`. All bits are initially `false`.
  Parameters:
    `nbits` - the initial size of the bit set.
  Throws:
    `NegativeArraySizeException` - if the specified initial size is negative.

Method Detail

### length

    public int length()

  Returns the "logical size" of this `BitSet`: the index of the highest set bit in the `BitSet` plus one. Returns zero if the `BitSet` contains no set bits.
  Returns:
    the logical size of this `BitSet`.
  Since:
    1.2

### set

    public void set(int bitIndex)

  Sets the bit specified by the index to `true`.
  Parameters:
    `bitIndex` - a bit index.
  Throws:
    `IndexOutOfBoundsException` - if the specified index is negative.
  Since:
    JDK1.0

### clear

    public void clear(int bitIndex)

  Sets the bit specified by the index to `false`.
  Parameters:
    `bitIndex` - the index of the bit to be cleared.
  Throws:
    `IndexOutOfBoundsException` - if the specified index is negative.
  Since:
    JDK1.0

### andNot

    public void andNot(BitSet set)

  Clears all of the bits in this `BitSet` whose corresponding bit is set in the specified `BitSet`.
  Parameters:
    `set` - the `BitSet` with which to mask this `BitSet`.
  Since:
    1.2

### get

    public boolean get(int bitIndex)

  Returns the value of the bit with the specified index. The value is `true` if the bit with the index `bitIndex` is currently set in this `BitSet`; otherwise, the result is `false`.
  Parameters:
    `bitIndex` - the bit index.
  Returns:
    the value of the bit with the specified index.
  Throws:
    `IndexOutOfBoundsException` - if the specified index is negative.

### and

    public void and(BitSet set)

  Performs a logical AND of this target bit set with the argument bit set. This bit set is modified so that each bit in it has the value `true` if and only if it both initially had the value `true` and the corresponding bit in the bit set argument also had the value `true`.
  Parameters:
    `set` - a bit set.

### or

    public void or(BitSet set)

  Performs a logical OR of this bit set with the bit set argument. This bit set is modified so that a bit in it has the value `true` if and only if it either already had the value `true` or the corresponding bit in the bit set argument has the value `true`.
  Parameters:
    `set` - a bit set.

### xor

    public void xor(BitSet set)

  Performs a logical XOR of this bit set with the bit set argument. This bit set is modified so that a bit in it has the value `true` if and only if one of the following statements holds:
  - 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`.
  Parameters:
    `set` - a bit set.

### hashCode

    public int hashCode()

  Returns a hash code value for this bit set. The has code depends only on which bits have been set within this `BitSet`. The algorithm used to compute it may be described as follows.

  Suppose the bits in the `BitSet` were to be stored in an array of `long` integers called, say, `bits`, in such a manner that bit `k` is set in the `BitSet` (for nonnegative values of `k`) if and only if the expression

      ((k>>6) < bits.length) && ((bits[k>>6] & (1L << (bit & 0x3F))) != 0)

  is true. Then the following definition of the `hashCode` method would be a correct implementation of the actual algorithm:

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

  Note that the hash code values change if the set of bits is altered.

  Overrides the `hashCode` method of `Object`.

  Overrides:
    `hashCode` in class `Object`
  Returns:
    a hash code value for this bit set.

### size

    public int size()

  Returns the number of bits of space actually in use by this `BitSet` to represent bit values. The maximum element in the set is the size - 1st element.
  Returns:
    the number of bits currently in this bit set.

### equals

    public boolean equals(Object obj)

  Compares this object against the specified object. The result is `true` if and only if the argument is not `null` and is a `Bitset` object that has exactly the same set of bits set to `true` as this bit set. That is, for every nonnegative `int` index `k`,

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

  must be true. The current sizes of the two bit sets are not compared.

  Overrides the `equals` method of `Object`.

  Overrides:
    `equals` in class `Object`
  Parameters:
    `obj` - the object to compare with.
  Returns:
    `true` if the objects are the same; `false` otherwise.
  See Also:
    `size()`

### clone

    public Object clone()

  Cloning this `BitSet` produces a new `BitSet` that is equal to it. The clone of the bit set is another bit set that has exactly the same bits set to `true` as this bit set and the same current size.

  Overrides the `clone` method of `Object`.

  Overrides:
    `clone` in class `Object`
  Returns:
    a clone of this bit set.
  See Also:
    `size()`

### toString

    public String toString()

  Returns a string representation of this bit set. For every index for which this `BitSet` contains a bit in the set state, the decimal representation of that index is included in the result. Such indeces aer listed in order from lowest to highest, separated by ",$nbsp;" (a comma and a space) and surrounded by braces, resulting in the usual mathematical notation for a set of integers.

  Overrides the `toString` method of `Object`.

  Example:

       BitSet drPepper = new BitSet();

  Now `drPepper.toString()` returns "`{}`".

       drPepper.set(2);

  Now `drPepper.toString()` returns "`{2}`".

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

  Now `drPepper.toString()` returns "`{2, 4, 10}`".
  Overrides:
    `toString` in class `Object`
  Returns:
    a string representation of this bit set.

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| J2ME Foundation
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: INNER | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Java is a trademark or registred trademark of Sun Microsystems, Inc. in the US and other countries.
Copyright 1993-2000 Sun Microsystems, Inc. 901 San Antonio Road,
Palo, Alto, California, 94303, U.S.A All Rights Reserved. < /font >