net.cscott.jutil (JUtil documentation)

Interface Summary
Interface	Description
Environment<K,V>	An `Environment` is a `Map` with scoping: you can save marks into the environment and undo all changes since a mark.
Environment.Mark	A abstract property for marks into an environment.
Heap<K,V>	`Heap`s support create, insert, minimum, extract-min, union, decrease-key, and delete operations.
InvertibleMap<K,V>	An `InvertibleMap` is an extension of the `Map` interface to allow users to do reverse lookups on the mappings maintained.
InvertibleMultiMap<K,V>	An `InvertibleMultiMap` is an extension of the `MultiMap` interface to allow users to do reverse lookups on the mappings maintained.
MapSet<K,V>	A `MapSet` is a `Set` of `Map.Entry`s which can also be accessed as a `Map`.
MultiMap<K,V>	`MultiMap` maps a key to a collection of values.
MultiMapSet<K,V>	A `MultiMapSet` is a `Set` of `Map.Entry`s which can also be accessed as a `MultiMap`.
ReferenceUnique	`ReferenceUnique` is a property indicating that, for all instances of a class, `(a==b)==(a.equals(b))`.

Class Summary
Class	Description
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, 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 `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 one-off or 'standard, no-frills' 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 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 `CollectionFactory`s.
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 `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 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 `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 hash-consing to ensure that the `Map`s created by it maximally reuse space.
PersistentMultiMapFactory<K,V>	A `PersistentMultiMapFactory` uses hash-consing 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 hash-consing to ensure that the `Set`s created by it maximally reuse space.
RedBlackTree	A `RedBlackTree` is a `BinaryTree` that uses red-black 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 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 `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.

Package net.cscott.jutil