Looking for a real "BitSet"

Question

Hi all,
I'm looking for an efficient set implementation based on bit vectors. BitSet doesn't support the set interface. EnumSet requires you to know the set of elements at compile time, which I don't.
I guess I could subclass BitSet, implementing the Set interface, but I was hoping someone could point me toward an existing solution.
Thanks!
David

Answer 1

I didn't find anything in the Jakarta collections. So I went ahead and implemented a "FixedSet" which is like EnumSet but is based on a collection that specifies the universe at runtime, instead of an enum that specifies the universe at compile time.
For example:
HashSet<String> universe = new HashSet<String>;
universe.add("a");
universe.add("b");
universe.add("c");
universe.add("d");
universe.add("e");
// Fast bit vector based implementation
FixedSet<X> fixedSet = FixedSet.noneOf(universe);
fixedSet.add("a");
// Throws "element not in universe" exception
fixedSet.contains("z");To test the performance, I created a universe of 150 enumerated values, then a set containing 100 values. Then I ran "contains" 30M times for 100 elements, 50 of which were in the set. Results:
TreeSet: 25 seconds
EnumSet: 2 seconds
FixedSet: 10 seconds
Profiling the code, the performance loss seems to be in a HashMap I use to map the Object to its index into the array of all elements. e.g.:
public abstract class FixedSet<E> extends AbstractSet<E>
  implements Cloneable, java.io.Serializable
  // All of the values comprising E for this set.
  protected E[] universe;
  // For reverse lookup
  protected Hashtable<E,Integer> ordinal;I have to do this because E doesn't necessarily have an ordinal value (EnumSet uses Enum.ordinal()). Unfortunately the hash lookup is now a bottleneck.
This brings me to my next question: I was thinking of replacing the hashtable by creating an inner class that extends E and adds an ordinal value that I initialize during creation of the FixedSet. e.g.:
public abstract class FixedSet<E> extends AbstractSet<E>
  implements Cloneable, java.io.Serializable
  // All of the values comprising E for this set.
  protected EOrdinal[] universe;
  protected class EOrdinal extends E {
    int ordinal;
    int ordinal() { return ordinal; }
  }The compiler doesn't like this. Can anyone suggest a solution?