Class Summary 
AbstractHeap<K,V> 
AbstractHeap provides a skeletal implementation of
the Heap interface, to minimize the effort required
to implement this interface. 
AbstractMapEntry<K,V> 
An AbstractMapEntry takes care of most of the grunge
work involved in subclassing Map.Entry . 
AbstractMultiMap<K,V> 
This class provides a skeletal implementation of the MultiMap
interface, to minimize the effort requires to implement this interface. 
AggregateMapFactory<K,V> 
AggregateMapFactory uses a single HashMap
as backing store for the many smaller Map s created
by this MapFactory . 
AggregateSetFactory<V> 
AggregateSetFactory uses a single HashMap
as backing store for the many smaller Set s created
by this SetFactory . 
BinaryHeap<K,V> 
BinaryHeap is an implementation of a binary heap. 
BinaryTree 
A BinaryTree is a Tree where each node has
at most two children. 
BinomialHeap<K,V> 
A BinomialHeap allows
O(lg n) time bounds for insert, minimum, extractmin, union,
decreasekey, and delete operations. 
BitSetFactory<V> 
BitSetFactory is a SetFactory that,
given a complete universe of possible values, produces low space
overhead representations of Set s. 
BitString 
BitString implements a vector of bits

CollectionFactory<V> 
CollectionFactory is a Collection
generator. 
CollectionWrapper<E> 
CollectionWrapper is a class that acts as a wrapper
around another Collection, using it as its backing store. 
CombineIterator<E> 
A CombineIterator combines several different
Iterator s into one. 
Default 
Default contains oneoff or 'standard, nofrills'
implementations of simple Iterator s,
Collection s, and Comparator s. 
Default.PairList<A,B> 
Pairs, implemented as a List . 
DisjointSet<E> 
DisjointSet is an implementation of disjointset forests
using the path compression and unionbyrank heuristics to achieve
O(m * alpha(m, n)) runtime, where 'm' is the total number of
operations, 'n' is the total number of elements in the set, and
'alpha' denotes the *extremely* slowlygrowing inverse Ackermann
function. 
Factories 
Factories consists exclusively of static methods that
operate on or return CollectionFactory s. 
FibonacciHeap<K,V> 
A FibonacciHeap allows amortized O(1) time bounds for
create, insert, minimum, union, and decreasekey operations, and
amortized O(lg n) run times for extractmin and delete. 
FilterIterator<A,B> 
A FilterIterator filters and maps a source
Iterator to generate a new one. 
FilterIterator.Filter<A,B> 

GenericInvertibleMap<K,V> 
GenericInvertibleMap is a default implementation of
InvertibleMap . 
GenericInvertibleMultiMap<K,V> 
GenericInvertibleMultiMap is a default implementation of
InvertibleMultiMap . 
GenericMultiMap<K,V> 
GenericMultiMap is a default implementation of a
MultiMap . 
GenericMultiMapFactory<K,V> 
GenericMultiMapFactory implements MultiMapFactory
using instances of GenericMultiMap . 
HashEnvironment<K,V> 
A HashEnvironment is an Environment using
a HashMap as the backing store. 
Indexer<T> 
Indexer is an object for extracting unique indices
for a set of objects. 
IntervalTree 
An IntervalTree is a mutable collection
of IntervalTree.Interval s. 
IntervalTree.Interval 
Immutable record representing a closed interval
[low ,high ] holding an object
obj . 
IteratorEnumerator<E> 
An IteratorEnumerator converts an Iterator
into an Enumeration . 
LinearMap<K,V> 
LinearMap is a simplistic lightweight
Map designed for use when the number of entries is
small. 
LinearSet<E> 
LinearSet is a simplistic lightweight
Set designed for use when the number of entries is
small. 
ListFactory<V> 
ListFactory is a List generator. 
ListWrapper<E> 
ListWrapper is an abstract class designed to make it easier
to write wrappers around List s. 
MapFactory<K,V> 
MapFactory is a Map generator. 
MapWrapper<K,V> 
MapWrapper is a class that acts as a proxy for
another backing map, to allow for easy extension of
Map functionality while not restricting developers to
one particular Map implementation. 
MultiMapFactory<K,V> 
MultiMapFactory is a MultiMap generator. 
PairMapEntry<K,V> 
PairMapEntry is the easiest implementation of a
Map.Entry ever: a pair! 
PersistentEnvironment<K,V> 
PersistentEnvironment is an Environment
built on a PersistentMap . 
PersistentMap<K,V> 
PersistentMap implements a persistent map, based on a
persistent randomized treap. 
PersistentMapFactory<K,V> 
A PersistentMapFactory uses hashconsing to ensure that
the Map s created by it maximally reuse space. 
PersistentMultiMapFactory<K,V> 
A PersistentMultiMapFactory uses hashconsing to ensure that
the MultiMap s created by it maximally reuse space. 
PersistentSet<T> 
PersistentSet implements a persistent set, based on a
persistent randomized treap. 
PersistentSetFactory<T> 
A PersistentSetFactory uses hashconsing to ensure that
the Set s created by it maximally reuse space. 
RedBlackTree 
A RedBlackTree is a BinaryTree that uses
redblack properties to maintain a balanced form. 
ReverseIterator<E> 
A ReverseIterator iterates through an Iterator
in reverse order. 
ReverseListIterator<E> 
ReverseListIterator takes a List and gives
you an Iterator that traverses the list in reverse
order. 
SetFactory<V> 
SetFactory is a Set generator. 
SetWrapper<E> 
SetWrapper is analogous to
CollectionWrapper , specialized for Set s. 
SnapshotIterator<E> 
A SnapshotIterator takes a "snapshot" of an iterator,
and iterates over that snapshot. 
UniqueStack<E> 
The UniqueStack class represents a lastinfirstout
stack of unique objects. 
UniqueVector<E> 
A unique vector refuses to addElement duplicates. 
UnmodifiableIterator<E> 
UnmodifiableIterator is an abstract superclass to save
you the trouble of implementing the UnmodifiableIterator.remove() method
over and over again for those iterators which don't implement it. 
UnmodifiableListIterator<E> 
UnmodifiableListIterator is an abstract superclass to
save you the trouble of implementing the UnmodifiableListIterator.remove() ,
UnmodifiableListIterator.add(Object) and UnmodifiableListIterator.set(Object) methods over and over again
for those list iterators which don't implement them. 
UnmodifiableMap<K,V> 
This wrapper for Map s implements Map.entrySet()
so that it returns an UnmodifiableMapSet . 
UnmodifiableMapSet<K,V> 
UnmodifiableMapSet prevents mutation of a wrapped
MapSet . 
UnmodifiableMultiMap<K,V> 
UnmodifiableMultiMap is an abstract superclass to
save developers the trouble of implementing the various mutator
methds of the MultiMap interface. 
UnmodifiableMultiMapSet<K,V> 
UnmodifiableMultiMapSet prevents mutation of a wrapped
MultiMapSet . 
Util 
Miscellaneous static utility functions. 
Version 
The Version object contains fields naming the current version
of the jutil library (1.4). 
WorkSet<E> 
Deprecated. Use LinkedHashSet instead. 