All Classes

Class	Description
AbstractBagDecorator<E>	Decorates another Bag to provide additional behaviour.
AbstractBidiMapDecorator<K,V>	Provides a base decorator that enables additional functionality to be added to a BidiMap via decoration.
AbstractBitwiseTrie<K,V>	This class provides some basic Trie functionality and utility methods for actual bitwise Trie implementations.
AbstractCollectionDecorator<E>	Decorates another Collection to provide additional behaviour.
AbstractDualBidiMap<K,V>	Abstract BidiMap implemented using two maps.
AbstractDualBidiMap.BidiMapIterator<K,V>	Inner class MapIterator.
AbstractDualBidiMap.EntrySet<K,V>	Inner class EntrySet.
AbstractDualBidiMap.EntrySetIterator<K,V>	Inner class EntrySetIterator.
AbstractDualBidiMap.KeySet<K>	Inner class KeySet.
AbstractDualBidiMap.KeySetIterator<K>	Inner class KeySetIterator.
AbstractDualBidiMap.MapEntry<K,V>	Inner class MapEntry.
AbstractDualBidiMap.Values<V>	Inner class Values.
AbstractDualBidiMap.ValuesIterator<V>	Inner class ValuesIterator.
AbstractDualBidiMap.View<K,V,E>	Inner class View.
AbstractEmptyMapIterator<K,V>	Provides an implementation of an empty map iterator.
AbstractHashedMap<K,V>	An abstract implementation of a hash-based map which provides numerous points for subclasses to override.
AbstractHashedMap.EntrySet<K,V>	EntrySet implementation.
AbstractHashedMap.EntrySetIterator<K,V>	EntrySet iterator.
AbstractHashedMap.HashEntry<K,V>	HashEntry used to store the data.
AbstractHashedMap.HashIterator<K,V>	Base Iterator
AbstractHashedMap.HashMapIterator<K,V>	MapIterator implementation.
AbstractHashedMap.KeySet<K>	KeySet implementation.
AbstractHashedMap.KeySetIterator<K>	KeySet iterator.
AbstractHashedMap.Values<V>	Values implementation.
AbstractHashedMap.ValuesIterator<V>	Values iterator.
AbstractIterableGetMapDecorator<K,V>	IterableGet that uses a Map<K, V> for the Get<K, V> implementation.
AbstractIterableMap<K,V>	Provide a basic IterableMap implementation.
AbstractIteratorDecorator<E>	Provides basic behaviour for decorating an iterator with extra functionality.
AbstractKeyValue<K,V>	Abstract pair class to assist with creating KeyValue and Map.Entry implementations.
AbstractLinkedList<E>	An abstract implementation of a linked list which provides numerous points for subclasses to override.
AbstractLinkedList.LinkedListIterator<E>	A list iterator over the linked list.
AbstractLinkedList.LinkedSubList<E>	The sublist implementation for AbstractLinkedList.
AbstractLinkedList.LinkedSubListIterator<E>	A list iterator over the linked sub list.
AbstractLinkedList.Node<E>	A node within the linked list.
AbstractLinkedMap<K,V>	An abstract implementation of a hash-based map that links entries to create an ordered map and which provides numerous points for subclasses to override.
AbstractLinkedMap.EntrySetIterator<K,V>	EntrySet iterator.
AbstractLinkedMap.KeySetIterator<K>	KeySet iterator.
AbstractLinkedMap.LinkEntry<K,V>	LinkEntry that stores the data.
AbstractLinkedMap.LinkIterator<K,V>	Base Iterator that iterates in link order.
AbstractLinkedMap.LinkMapIterator<K,V>	MapIterator implementation.
AbstractLinkedMap.ValuesIterator<V>	Values iterator.
AbstractListDecorator<E>	Decorates another List to provide additional behaviour.
AbstractListIteratorDecorator<E>	Provides basic behaviour for decorating a list iterator with extra functionality.
AbstractListValuedMap<K,V>	Abstract implementation of the ListValuedMap interface to simplify the creation of subclass implementations.
AbstractMapBag<E>	Abstract implementation of the Bag interface to simplify the creation of subclass implementations.
AbstractMapBag.MutableInteger	Mutable integer class for storing the data.
AbstractMapDecorator<K,V>	Provides a base decorator that enables additional functionality to be added to a Map via decoration.
AbstractMapEntry<K,V>	Abstract Pair class to assist with creating correct Map.Entry implementations.
AbstractMapEntryDecorator<K,V>	Provides a base decorator that allows additional functionality to be added to a Map.Entry.
AbstractMapIteratorDecorator<K,V>	Provides basic behaviour for decorating a map iterator with extra functionality.
AbstractMapMultiSet<E>	Abstract implementation of the MultiSet interface to simplify the creation of subclass implementations.
AbstractMapMultiSet.EntrySetIterator<E>	Inner class EntrySetIterator.
AbstractMapMultiSet.MultiSetEntry<E>	Inner class MultiSetEntry.
AbstractMapMultiSet.MutableInteger	Mutable integer class for storing the data.
AbstractMapMultiSet.UniqueSetIterator<E>	Inner class UniqueSetIterator.
AbstractMultiSet<E>	Abstract implementation of the MultiSet interface to simplify the creation of subclass implementations.
AbstractMultiSet.AbstractEntry<E>	Inner class AbstractEntry.
AbstractMultiSet.EntrySet<E>	Inner class EntrySet.
AbstractMultiSet.UniqueSet<E>	Inner class UniqueSet.
AbstractMultiSetDecorator<E>	Decorates another MultSet to provide additional behaviour.
AbstractMultiValuedMap<K,V>	Abstract implementation of the MultiValuedMap interface to simplify the creation of subclass implementations.
AbstractMultiValuedMapDecorator<K,V>	Decorates another MultiValuedMap to provide additional behaviour.
AbstractNavigableSetDecorator<E>	Decorates another NavigableSet to provide additional behaviour.
AbstractOrderedBidiMapDecorator<K,V>	Provides a base decorator that enables additional functionality to be added to an OrderedBidiMap via decoration.
AbstractOrderedMapDecorator<K,V>	Provides a base decorator that enables additional functionality to be added to an OrderedMap via decoration.
AbstractOrderedMapIteratorDecorator<K,V>	Provides basic behaviour for decorating an ordered map iterator with extra functionality.
AbstractQuantifierPredicate<T>	Abstract base class for quantification predicates, e.g.
AbstractQueueDecorator<E>	Decorates another Queue to provide additional behaviour.
AbstractReferenceMap<K,V>	An abstract implementation of a hash-based map that allows the entries to be removed by the garbage collector.
AbstractReferenceMap.ReferenceEntry<K,V>	A MapEntry implementation for the map.
AbstractReferenceMap.ReferenceStrength	Reference type enum.
AbstractSerializableListDecorator<E>	Serializable subclass of AbstractListDecorator.
AbstractSerializableSetDecorator<E>	Serializable subclass of AbstractSetDecorator.
AbstractSetDecorator<E>	Decorates another Set to provide additional behaviour.
AbstractSetValuedMap<K,V>	Abstract implementation of the SetValuedMap interface to simplify the creation of subclass implementations.
AbstractSortedBagDecorator<E>	Decorates another SortedBag to provide additional behaviour.
AbstractSortedBidiMapDecorator<K,V>	Provides a base decorator that enables additional functionality to be added to a SortedBidiMap via decoration.
AbstractSortedMapDecorator<K,V>	Provides a base decorator that enables additional functionality to be added to a Map via decoration.
AbstractSortedMapDecorator.SortedMapIterator<K,V>	OrderedMapIterator implementation.
AbstractSortedSetDecorator<E>	Decorates another SortedSet to provide additional behaviour.
AbstractUntypedIteratorDecorator<I,O>	Provides basic behaviour for decorating an iterator with extra functionality without committing the generic type of the Iterator implementation.
AllPredicate<T>	Predicate implementation that returns true if all the predicates return true.
AndPredicate<T>	Predicate implementation that returns true if both the predicates return true.
AnyPredicate<T>	Predicate implementation that returns true if any of the predicates return true.
ArrayIterator<E>	Implements an Iterator over any array.
ArrayListIterator<E>	Implements a ListIterator over an array.
ArrayListValuedHashMap<K,V>	Implements a ListValuedMap, using a HashMap to provide data storage and ArrayLists as value collections.
ArrayStack<E>	Deprecated. use ArrayDeque instead (available from Java 1.6)
Bag<E>	Defines a collection that counts the number of times an object appears in the collection.
BagUtils	Provides utility methods and decorators for Bag and SortedBag instances.
BidiMap<K,V>	Defines a map that allows bidirectional lookup between key and values.
BooleanComparator	A Comparator for Boolean objects that can sort either true or false first.
BoundedCollection<E>	Defines a collection that is bounded in size.
BoundedIterator<E>	Decorates another iterator to return elements in a specific range.
BoundedMap<K,V>	Defines a map that is bounded in size.
CaseInsensitiveMap<K,V>	A case-insensitive Map.
CatchAndRethrowClosure<E>	Closure that catches any checked exception and re-throws it as a FunctorException runtime exception.
ChainedClosure<E>	Closure implementation that chains the specified closures together.
ChainedTransformer<T>	Transformer implementation that chains the specified transformers together.
CircularFifoQueue<E>	CircularFifoQueue is a first-in first-out queue with a fixed size that replaces its oldest element if full.
CloneTransformer<T>	Transformer implementation that returns a clone of the input object.
Closure<T>	Defines a functor interface implemented by classes that do something.
ClosureTransformer<T>	Transformer implementation that calls a Closure using the input object and then returns the input.
ClosureUtils	ClosureUtils provides reference implementations and utilities for the Closure functor interface.
CollatingIterator<E>	Provides an ordered iteration over the elements contained in a collection of ordered Iterators.
CollectionBag<E>	Decorates another Bag to comply with the Collection contract.
CollectionSortedBag<E>	Decorates another SortedBag to comply with the Collection contract.
CollectionUtils	Provides utility methods and decorators for Collection instances.
CommandVisitor<T>	This interface should be implemented by user object to walk through EditScript objects.
ComparableComparator<E extends Comparable<? super E>>	A Comparator that compares Comparable objects.
ComparatorChain<E>	A ComparatorChain is a Comparator that wraps one or more Comparators in sequence.
ComparatorPredicate<T>	Predicate that compares the input object with the one stored in the predicate using a comparator.
ComparatorPredicate.Criterion
ComparatorUtils	Provides convenient static utility methods for Comparator objects.
CompositeCollection<E>	Decorates a collection of other collections to provide a single unified view.
CompositeCollection.CollectionMutator<E>	Pluggable strategy to handle changes to the composite.
CompositeMap<K,V>	Decorates a map of other maps to provide a single unified view.
CompositeMap.MapMutator<K,V>	This interface allows definition for all of the indeterminate mutators in a CompositeMap, as well as providing a hook for callbacks on key collisions.
CompositeSet<E>	Decorates a set of other sets to provide a single unified view.
CompositeSet.SetMutator<E>	Define callbacks for mutation operations.
ConstantFactory<T>	Factory implementation that returns the same constant each time.
ConstantTransformer<I,O>	Transformer implementation that returns the same constant each time.
CursorableLinkedList<E>	A List implementation with a ListIterator that allows concurrent modifications to the underlying list.
CursorableLinkedList.Cursor<E>	An extended ListIterator that allows concurrent changes to the underlying list.
CursorableLinkedList.SubCursor<E>	A cursor for the sublist based on LinkedSubListIterator.
DefaultedMap<K,V>	Decorates another Map returning a default value if the map does not contain the requested key.
DefaultEquator<T>	Default Equator implementation.
DefaultKeyValue<K,V>	A mutable KeyValue pair that does not implement Map.Entry.
DefaultMapEntry<K,V>	A restricted implementation of Map.Entry that prevents the Map.Entry contract from being broken.
DeleteCommand<T>	Command representing the deletion of one object of the first sequence.
DualHashBidiMap<K,V>	Implementation of BidiMap that uses two HashMap instances.
DualLinkedHashBidiMap<K,V>	Implementation of BidiMap that uses two LinkedHashMap instances.
DualTreeBidiMap<K,V>	Implementation of BidiMap that uses two TreeMap instances.
DualTreeBidiMap.BidiOrderedMapIterator<K,V>	Inner class MapIterator.
DualTreeBidiMap.ViewMap<K,V>	Internal sorted map view.
EditCommand<T>	Abstract base class for all commands used to transform an objects sequence into another one.
EditScript<T>	This class gathers all the commands needed to transform one objects sequence into another objects sequence.
EmptyIterator<E>	Provides an implementation of an empty iterator.
EmptyListIterator<E>	Provides an implementation of an empty list iterator.
EmptyMapIterator<K,V>	Provides an implementation of an empty map iterator.
EmptyOrderedIterator<E>	Provides an implementation of an empty ordered iterator.
EmptyOrderedMapIterator<K,V>	Provides an implementation of an empty ordered map iterator.
EntrySetMapIterator<K,V>	Implements a MapIterator using a Map entrySet.
EntrySetToMapIteratorAdapter<K,V>	Adapts a Map entrySet to the MapIterator interface.
EnumerationIterator<E>	Adapter to make Enumeration instances appear to be Iterator instances.
EnumerationUtils	Provides utility methods for Enumeration instances.
EqualPredicate<T>	Predicate implementation that returns true if the input is the same object as the one stored in this predicate by equals.
Equator<T>	An equation function, which determines equality between objects of type T.
ExceptionClosure<E>	Closure implementation that always throws an exception.
ExceptionFactory<T>	Factory implementation that always throws an exception.
ExceptionPredicate<T>	Predicate implementation that always throws an exception.
ExceptionTransformer<I,O>	Transformer implementation that always throws an exception.
Factory<T>	Defines a functor interface implemented by classes that create objects.
FactoryTransformer<I,O>	Transformer implementation that calls a Factory and returns the result.
FactoryUtils	FactoryUtils provides reference implementations and utilities for the Factory functor interface.
FalsePredicate<T>	Predicate implementation that always returns false.
FilterIterator<E>	Decorates another Iterator using a predicate to filter elements.
FilterListIterator<E>	Decorates another ListIterator using a predicate to filter elements.
FixedOrderComparator<T>	A Comparator which imposes a specific order on a specific set of Objects.
FixedOrderComparator.UnknownObjectBehavior	Unknown object behavior enum.
FixedSizeList<E>	Decorates another List to fix the size preventing add/remove.
FixedSizeMap<K,V>	Decorates another Map to fix the size, preventing add/remove.
FixedSizeSortedMap<K,V>	Decorates another SortedMap to fix the size blocking add/remove.
Flat3Map<K,V>	A Map implementation that stores data in simple fields until the size is greater than 3.
FluentIterable<E>	A FluentIterable provides a powerful yet simple API for manipulating Iterable instances in a fluent manner.
ForClosure<E>	Closure implementation that calls another closure n times, like a for loop.
FunctorException	Runtime exception thrown from functors.
Get<K,V>	The "read" subset of the Map interface.
GrowthList<E>	Decorates another List to make it seamlessly grow when indices larger than the list size are used on add and set, avoiding most IndexOutOfBoundsExceptions.
HashBag<E>	Implements Bag, using a HashMap to provide the data storage.
HashedMap<K,V>	A Map implementation that is a general purpose alternative to HashMap.
HashMultiSet<E>	Implements MultiSet, using a HashMap to provide the data storage.
HashSetValuedHashMap<K,V>	Implements a SetValuedMap, using a HashMap to provide data storage and HashSets as value collections.
IdentityPredicate<T>	Predicate implementation that returns true if the input is the same object as the one stored in this predicate.
IfClosure<E>	Closure implementation acts as an if statement calling one or other closure based on a predicate.
IfTransformer<I,O>	Transformer implementation that will call one of two closures based on whether a predicate evaluates as true or false.
IndexedCollection<K,C>	An IndexedCollection is a Map-like view onto a Collection.
InsertCommand<T>	Command representing the insertion of one object of the second sequence.
InstanceofPredicate	Predicate implementation that returns true if the input is an instanceof the type stored in this predicate.
InstantiateFactory<T>	Factory implementation that creates a new object instance by reflection.
InstantiateTransformer<T>	Transformer implementation that creates a new object instance by reflection.
InvokerTransformer<I,O>	Transformer implementation that creates a new object instance by reflection.
IterableGet<K,V>	The "read" subset of the Map interface.
IterableMap<K,V>	Defines a map that can be iterated directly without needing to create an entry set.
IterableSortedMap<K,V>	SortedMap + OrderedMap.
IterableUtils	Provides utility methods and decorators for Iterable instances.
IteratorChain<E>	An IteratorChain is an Iterator that wraps a number of Iterators.
IteratorEnumeration<E>	Adapter to make an Iterator instance appear to be an Enumeration instance.
IteratorIterable<E>	Adapter to make an Iterator instance appear to be an Iterable instance.
IteratorUtils	Provides static utility methods and decorators for Iterator instances.
KeepCommand<T>	Command representing the keeping of one object present in both sequences.
KeyAnalyzer<K>	Defines the interface to analyze Trie keys on a bit level.
KeyValue<K,V>	Defines a simple key value pair.
LazyIteratorChain<E>	An LazyIteratorChain is an Iterator that wraps a number of Iterators in a lazy manner.
LazyList<E>	Decorates another List to create objects in the list on demand.
LazyMap<K,V>	Decorates another Map to create objects in the map on demand.
LazySortedMap<K,V>	Decorates another SortedMap to create objects in the map on demand.
LinkedMap<K,V>	A Map implementation that maintains the order of the entries.
ListIteratorWrapper<E>	Converts an Iterator into a ResettableListIterator.
ListOrderedMap<K,V>	Decorates a Map to ensure that the order of addition is retained using a List to maintain order.
ListOrderedSet<E>	Decorates another Set to ensure that the order of addition is retained and used by the iterator.
ListUtils	Provides utility methods and decorators for List instances.
ListValuedMap<K,V>	Defines a map that holds a list of values against each key.
LoopingIterator<E>	An Iterator that restarts when it reaches the end.
LoopingListIterator<E>	A ListIterator that restarts when it reaches the end or when it reaches the beginning.
LRUMap<K,V>	A Map implementation with a fixed maximum size which removes the least recently used entry if an entry is added when full.
MapBackedSet<E,V>	Decorates a Map to obtain Set behaviour.
MapIterator<K,V>	Defines an iterator that operates over a Map.
MapTransformer<I,O>	Transformer implementation that returns the value held in a specified map using the input parameter as a key.
MapUtils	Provides utility methods and decorators for Map and SortedMap instances.
MultiKey<K>	A MultiKey allows multiple map keys to be merged together.
MultiKeyMap<K,V>	A Map implementation that uses multiple keys to map the value.
MultiMap<K,V>	Deprecated. since 4.1, use MultiValuedMap instead
MultiMapUtils	Provides utility methods and decorators for MultiValuedMap instances.
MultiSet<E>	Defines a collection that counts the number of times an object appears in the collection.
MultiSet.Entry<E>	An unmodifiable entry for an element and its occurrence as contained in a MultiSet.
MultiSetUtils	Provides utility methods and decorators for MultiSet instances.
MultiValuedMap<K,V>	Defines a map that holds a collection of values against each key.
MultiValueMap<K,V>	Deprecated. since 4.1, use MultiValuedMap instead
NodeCachingLinkedList<E>	A List implementation that stores a cache of internal Node objects in an effort to reduce wasteful object creation.
NodeListIterator	An Iterator over a NodeList.
NonePredicate<T>	Predicate implementation that returns true if none of the predicates return true.
NOPClosure<E>	Closure implementation that does nothing.
NOPTransformer<T>	Transformer implementation that does nothing.
NotNullPredicate<T>	Predicate implementation that returns true if the input is not null.
NotPredicate<T>	Predicate implementation that returns the opposite of the decorated predicate.
NullComparator<E>	A Comparator that will compare nulls to be either lower or higher than other objects.
NullIsExceptionPredicate<T>	Predicate implementation that throws an exception if the input is null.
NullIsFalsePredicate<T>	Predicate implementation that returns false if the input is null.
NullIsTruePredicate<T>	Predicate implementation that returns true if the input is null.
NullPredicate<T>	Predicate implementation that returns true if the input is null.
ObjectArrayIterator<E>	An Iterator over an array of objects.
ObjectArrayListIterator<E>	Implements a ListIterator over an array of objects.
ObjectGraphIterator<E>	An Iterator that can traverse multiple iterators down an object graph.
OnePredicate<T>	Predicate implementation that returns true if only one of the predicates return true.
OrderedBidiMap<K,V>	Defines a map that allows bidirectional lookup between key and values and retains and provides access to an ordering.
OrderedIterator<E>	Defines an iterator that operates over an ordered container.
OrderedMap<K,V>	Defines a map that maintains order and allows both forward and backward iteration through that order.
OrderedMapIterator<K,V>	Defines an iterator that operates over an ordered Map.
OrPredicate<T>	Predicate implementation that returns true if either of the predicates return true.
PassiveExpiringMap<K,V>	Decorates a Map to evict expired entries once their expiration time has been reached.
PassiveExpiringMap.ConstantTimeToLiveExpirationPolicy<K,V>	A ExpirationPolicy that returns a expiration time that is a constant about of time in the future from the current time.
PassiveExpiringMap.ExpirationPolicy<K,V>	A policy to determine the expiration time for key-value entries.
PatriciaTrie<E>	Implementation of a PATRICIA Trie (Practical Algorithm to Retrieve Information Coded in Alphanumeric).
PeekingIterator<E>	Decorates an iterator to support one-element lookahead while iterating.
PermutationIterator<E>	This iterator creates permutations of an input collection, using the Steinhaus-Johnson-Trotter algorithm (also called plain changes).
Predicate<T>	Defines a functor interface implemented by classes that perform a predicate test on an object.
PredicatedBag<E>	Decorates another Bag to validate that additions match a specified predicate.
PredicatedCollection<E>	Decorates another Collection to validate that additions match a specified predicate.
PredicatedCollection.Builder<E>	Builder for creating predicated collections.
PredicateDecorator<T>	Defines a predicate that decorates one or more other predicates.
PredicatedList<E>	Decorates another List to validate that all additions match a specified predicate.
PredicatedMap<K,V>	Decorates another Map to validate that additions match a specified predicate.
PredicatedMultiSet<E>	Decorates another MultiSet to validate that additions match a specified predicate.
PredicatedNavigableSet<E>	Decorates another NavigableSet to validate that all additions match a specified predicate.
PredicatedQueue<E>	Decorates another Queue to validate that additions match a specified predicate.
PredicatedSet<E>	Decorates another Set to validate that all additions match a specified predicate.
PredicatedSortedBag<E>	Decorates another SortedBag to validate that additions match a specified predicate.
PredicatedSortedMap<K,V>	Decorates another SortedMap to validate that additions match a specified predicate.
PredicatedSortedSet<E>	Decorates another SortedSet to validate that all additions match a specified predicate.
PredicateTransformer<T>	Transformer implementation that calls a Predicate using the input object and then returns the result.
PredicateUtils	PredicateUtils provides reference implementations and utilities for the Predicate functor interface.
PrototypeFactory	Factory implementation that creates a new instance each time based on a prototype.
PushbackIterator<E>	Decorates an iterator to support pushback of elements.
Put<K,V>	The "write" subset of the Map interface.
QueueUtils	Provides utility methods and decorators for Queue instances.
ReferenceIdentityMap<K,V>	A Map implementation that allows mappings to be removed by the garbage collector and matches keys and values based on == not equals().
ReferenceMap<K,V>	A Map implementation that allows mappings to be removed by the garbage collector.
ReplacementsFinder<T>	This class handles sequences of replacements resulting from a comparison.
ReplacementsHandler<T>	This interface is devoted to handle synchronized replacement sequences.
ResettableIterator<E>	Defines an iterator that can be reset back to an initial state.
ResettableListIterator<E>	Defines a list iterator that can be reset back to an initial state.
ReverseComparator<E>	Reverses the order of another comparator by reversing the arguments to its compare method.
ReverseListIterator<E>	Iterates backwards through a List, starting with the last element and continuing to the first.
SequencesComparator<T>	This class allows to compare two objects sequences.
SetUniqueList<E>	Decorates a List to ensure that no duplicates are present much like a Set.
SetUtils	Provides utility methods and decorators for Set and SortedSet instances.
SetUtils.SetView<E>	An unmodifiable view of a set that may be backed by other sets.
SetValuedMap<K,V>	Defines a map that holds a set of values against each key.
SingletonIterator<E>	SingletonIterator is an Iterator over a single object instance.
SingletonListIterator<E>	SingletonIterator is an ListIterator over a single object instance.
SingletonMap<K,V>	A Map implementation that holds a single item and is fixed size.
SkippingIterator<E>	Decorates another iterator to skip the first N elements.
SortedBag<E>	Defines a type of Bag that maintains a sorted order among its unique representative members.
SortedBidiMap<K,V>	Defines a map that allows bidirectional lookup between key and values and retains both keys and values in sorted order.
SortedProperties	A drop-in replacement for Properties for sorting keys.
SplitMapUtils	Utilities for working with "split maps:" objects that implement Put and/or Get but not Map.
StaticBucketMap<K,V>	A StaticBucketMap is an efficient, thread-safe implementation of java.util.Map that performs well in in a highly thread-contentious environment.
StringKeyAnalyzer	An KeyAnalyzer for Strings.
StringValueTransformer<T>	Transformer implementation that returns the result of calling String.valueOf on the input object.
SwitchClosure<E>	Closure implementation calls the closure whose predicate returns true, like a switch statement.
SwitchTransformer<I,O>	Transformer implementation calls the transformer whose predicate returns true, like a switch statement.
SynchronizedBag<E>	Decorates another Bag to synchronize its behaviour for a multi-threaded environment.
SynchronizedCollection<E>	Decorates another Collection to synchronize its behaviour for a multi-threaded environment.
SynchronizedMultiSet<E>	Decorates another MultiSet to synchronize its behaviour for a multi-threaded environment.
SynchronizedQueue<E>	Decorates another Queue to synchronize its behaviour for a multi-threaded environment.
SynchronizedSortedBag<E>	Decorates another SortedBag to synchronize its behaviour for a multi-threaded environment.
TiedMapEntry<K,V>	A Map.Entry tied to a map underneath.
TransformedBag<E>	Decorates another Bag to transform objects that are added.
TransformedCollection<E>	Decorates another Collection to transform objects that are added.
TransformedList<E>	Decorates another List to transform objects that are added.
TransformedMap<K,V>	Decorates another Map to transform objects that are added.
TransformedMultiValuedMap<K,V>	Decorates another MultiValuedMap to transform objects that are added.
TransformedNavigableSet<E>	Decorates another NavigableSet to transform objects that are added.
TransformedPredicate<T>	Predicate implementation that transforms the given object before invoking another Predicate.
TransformedQueue<E>	Decorates another Queue to transform objects that are added.
TransformedSet<E>	Decorates another Set to transform objects that are added.
TransformedSortedBag<E>	Decorates another SortedBag to transform objects that are added.
TransformedSortedMap<K,V>	Decorates another SortedMap to transform objects that are added.
TransformedSortedSet<E>	Decorates another SortedSet to transform objects that are added.
TransformedSplitMap<J,K,U,V>	Decorates another Map to transform objects that are added.
Transformer<I,O>	Defines a functor interface implemented by classes that transform one object into another.
TransformerClosure<E>	Closure implementation that calls a Transformer using the input object and ignore the result.
TransformerPredicate<T>	Predicate implementation that returns the result of a transformer.
TransformerUtils	TransformerUtils provides reference implementations and utilities for the Transformer functor interface.
TransformingComparator<I,O>	Decorates another Comparator with transformation behavior.
TransformIterator<I,O>	Decorates an iterator such that each element returned is transformed.
TreeBag<E>	Implements SortedBag, using a TreeMap to provide the data storage.
TreeBidiMap<K extends Comparable<K>,V extends Comparable<V>>	Red-Black tree-based implementation of BidiMap where all objects added implement the Comparable interface.
TreeList<E>	A List implementation that is optimised for fast insertions and removals at any index in the list.
Trie<K,V>	Defines the interface for a prefix tree, an ordered tree data structure.
TrieUtils	A collection of Trie utilities.
TruePredicate<T>	Predicate implementation that always returns true.
UniqueFilterIterator<E>	A FilterIterator which only returns "unique" Objects.
UniquePredicate<T>	Predicate implementation that returns true the first time an object is passed into the predicate.
Unmodifiable	Marker interface for collections, maps and iterators that are unmodifiable.
UnmodifiableBag<E>	Decorates another Bag to ensure it can't be altered.
UnmodifiableBidiMap<K,V>	Decorates another BidiMap to ensure it can't be altered.
UnmodifiableBoundedCollection<E>	UnmodifiableBoundedCollection decorates another BoundedCollection to ensure it can't be altered.
UnmodifiableCollection<E>	Decorates another Collection to ensure it can't be altered.
UnmodifiableEntrySet<K,V>	Decorates a map entry Set to ensure it can't be altered.
UnmodifiableIterator<E>	Decorates an iterator such that it cannot be modified.
UnmodifiableList<E>	Decorates another List to ensure it can't be altered.
UnmodifiableListIterator<E>	Decorates a list iterator such that it cannot be modified.
UnmodifiableMap<K,V>	Decorates another Map to ensure it can't be altered.
UnmodifiableMapEntry<K,V>	A Map.Entry that throws UnsupportedOperationException when setValue is called.
UnmodifiableMapIterator<K,V>	Decorates a map iterator such that it cannot be modified.
UnmodifiableMultiSet<E>	Decorates another MultiSet to ensure it can't be altered.
UnmodifiableMultiValuedMap<K,V>	Decorates another MultiValuedMap to ensure it can't be altered.
UnmodifiableNavigableSet<E>	Decorates another NavigableSet to ensure it can't be altered.
UnmodifiableOrderedBidiMap<K,V>	Decorates another OrderedBidiMap to ensure it can't be altered.
UnmodifiableOrderedMap<K,V>	Decorates another OrderedMap to ensure it can't be altered.
UnmodifiableOrderedMapIterator<K,V>	Decorates an ordered map iterator such that it cannot be modified.
UnmodifiableQueue<E>	Decorates another Queue to ensure it can't be altered.
UnmodifiableSet<E>	Decorates another Set to ensure it can't be altered.
UnmodifiableSortedBag<E>	Decorates another SortedBag to ensure it can't be altered.
UnmodifiableSortedBidiMap<K,V>	Decorates another SortedBidiMap to ensure it can't be altered.
UnmodifiableSortedMap<K,V>	Decorates another SortedMap to ensure it can't be altered.
UnmodifiableSortedSet<E>	Decorates another SortedSet to ensure it can't be altered.
UnmodifiableTrie<K,V>	An unmodifiable Trie.
WhileClosure<E>	Closure implementation that executes a closure repeatedly until a condition is met, like a do-while or while loop.
ZippingIterator<E>	Provides an interleaved iteration over the elements contained in a collection of Iterators.