| 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 java.util.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 Maps created
by this MapFactory. |
| AggregateSetFactory<V> |
AggregateSetFactory uses a single HashMap
as backing store for the many smaller Sets created
by this SetFactory. |
| BinaryHeap<K,V> |
BinaryHeap is an implementation of a binary heap.
|
| BinaryTree | A BinaryTree is a {@code Tree} where each node has
at most two children.
|
| BinaryTree.Node | A Node is an element of this tree. |
| BinomialHeap<K,V> |
A BinomialHeap allows
O(lg n) time bounds for insert, minimum, extract-min, union,
decrease-key, and delete operations. |
| BitSetFactory<V> | BitSetFactory is a SetFactory that,
given a complete universe of possible values, produces low space
overhead representations of Sets.
|
| 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
Iterators into one.
|
| Default |
Default contains one-off or 'standard, no-frills'
implementations of simple Iterators,
Collections, and Comparators.
|
| Default.PairList<A,B> | Pairs, implemented as a List.
|
| DisjointSet<E> |
DisjointSet is an implementation of disjoint-set forests
using the path compression and union-by-rank 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* slowly-growing inverse Ackermann
function.
|
| Factories | Factories consists exclusively of static methods that
operate on or return CollectionFactorys. |
| FibonacciHeap<K,V> |
A FibonacciHeap allows amortized O(1) time bounds for
create, insert, minimum, union, and decrease-key operations, and
amortized O(lg n) run times for extract-min 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 Intervals. IntervalTrees support
efficient lookup of overlapping elements.
|
| 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 light-weight
Map designed for use when the number of entries is
small. |
| LinearSet<E> |
LinearSet is a simplistic light-weight
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 Lists.
|
| 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
java.util.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 hash-consing to ensure that
the Maps created by it maximally reuse space.
|
| PersistentMultiMapFactory<K,V> |
A PersistentMultiMapFactory uses hash-consing to ensure that
the MultiMaps created by it maximally reuse space.
|
| PersistentSet<T> |
PersistentSet implements a persistent set, based on a
persistent randomized treap. |
| PersistentSetFactory<T> |
A PersistentSetFactory uses hash-consing to ensure that
the Sets created by it maximally reuse space.
|
| RedBlackTree | A RedBlackTree is a BinaryTree that uses
red-black properties to maintain a balanced form. |
| RedBlackTree.RBNode | A RBNode is an element of this tree. |
| 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 Sets.
|
| SnapshotIterator<E> |
A SnapshotIterator takes a "snapshot" of an iterator,
and iterates over that snapshot. |
| UniqueStack<E> |
The UniqueStack class represents a last-in-first-out
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 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 remove,
UnmodifiableListIterator and UnmodifiableListIterator methods over and over again
for those list iterators which don't implement them. |
| UnmodifiableMap<K,V> |
This wrapper for Maps 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 library. |
| WorkSet<E> |
A WorkSet is a Set offering constant-time
access to the first/last element inserted, and an iterator whose speed
is not dependent on the total capacity of the underlying hashtable.
|