All Classes

Class	Description
AbstractBagDecorator	Decorates another Bag to provide additional behaviour.
AbstractBidiMapDecorator	Provides a base decorator that enables additional functionality to be added to a BidiMap via decoration.
AbstractBufferDecorator	Decorates another Buffer to provide additional behaviour.
AbstractCollectionDecorator	Decorates another Collection to provide additional behaviour.
AbstractDualBidiMap	Abstract BidiMap implemented using two maps.
AbstractDualBidiMap.BidiMapIterator	Inner class MapIterator.
AbstractDualBidiMap.EntrySet	Inner class EntrySet.
AbstractDualBidiMap.EntrySetIterator	Inner class EntrySetIterator.
AbstractDualBidiMap.KeySet	Inner class KeySet.
AbstractDualBidiMap.KeySetIterator	Inner class KeySetIterator.
AbstractDualBidiMap.MapEntry	Inner class MapEntry.
AbstractDualBidiMap.Values	Inner class Values.
AbstractDualBidiMap.ValuesIterator	Inner class ValuesIterator.
AbstractDualBidiMap.View	Inner class View.
AbstractHashedMap	An abstract implementation of a hash-based map which provides numerous points for subclasses to override.
AbstractHashedMap.EntrySet	EntrySet implementation.
AbstractHashedMap.EntrySetIterator	EntrySet iterator.
AbstractHashedMap.HashEntry	HashEntry used to store the data.
AbstractHashedMap.HashIterator	Base Iterator
AbstractHashedMap.HashMapIterator	MapIterator implementation.
AbstractHashedMap.KeySet	KeySet implementation.
AbstractHashedMap.KeySetIterator	KeySet iterator.
AbstractHashedMap.Values	Values implementation.
AbstractHashedMap.ValuesIterator	Values iterator.
AbstractIteratorDecorator	Provides basic behaviour for decorating an iterator with extra functionality.
AbstractKeyValue	Abstract pair class to assist with creating KeyValue and Map.Entry implementations.
AbstractLinkedList	An abstract implementation of a linked list which provides numerous points for subclasses to override.
AbstractLinkedList.LinkedListIterator	A list iterator over the linked list.
AbstractLinkedList.LinkedSubList	The sublist implementation for AbstractLinkedList.
AbstractLinkedList.LinkedSubListIterator	A list iterator over the linked sub list.
AbstractLinkedList.Node	A node within the linked list.
AbstractLinkedMap	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	EntrySet iterator.
AbstractLinkedMap.KeySetIterator	KeySet iterator.
AbstractLinkedMap.LinkEntry	LinkEntry that stores the data.
AbstractLinkedMap.LinkIterator	Base Iterator that iterates in link order.
AbstractLinkedMap.LinkMapIterator	MapIterator implementation.
AbstractLinkedMap.ValuesIterator	Values iterator.
AbstractListDecorator	Decorates another List to provide additional behaviour.
AbstractListIteratorDecorator	Provides basic behaviour for decorating a list iterator with extra functionality.
AbstractMapBag	Abstract implementation of the Bag interface to simplify the creation of subclass implementations.
AbstractMapBag.MutableInteger	Mutable integer class for storing the data.
AbstractMapDecorator	Provides a base decorator that enables additional functionality to be added to a Map via decoration.
AbstractMapEntry	Abstract Pair class to assist with creating correct Map.Entry implementations.
AbstractMapEntryDecorator	Provides a base decorator that allows additional functionality to be added to a Map.Entry.
AbstractMapIteratorDecorator	Provides basic behaviour for decorating a map iterator with extra functionality.
AbstractOrderedBidiMapDecorator	Provides a base decorator that enables additional functionality to be added to an OrderedBidiMap via decoration.
AbstractOrderedMapDecorator	Provides a base decorator that enables additional functionality to be added to an OrderedMap via decoration.
AbstractOrderedMapIteratorDecorator	Provides basic behaviour for decorating an ordered map iterator with extra functionality.
AbstractReferenceMap	An abstract implementation of a hash-based map that allows the entries to be removed by the garbage collector.
AbstractReferenceMap.ReferenceEntry	A MapEntry implementation for the map.
AbstractSerializableCollectionDecorator	Serializable subclass of AbstractCollectionDecorator.
AbstractSerializableListDecorator	Serializable subclass of AbstractListDecorator.
AbstractSerializableSetDecorator	Serializable subclass of AbstractSetDecorator.
AbstractSetDecorator	Decorates another Set to provide additional behaviour.
AbstractSortedBagDecorator	Decorates another SortedBag to provide additional behaviour.
AbstractSortedBidiMapDecorator	Provides a base decorator that enables additional functionality to be added to a SortedBidiMap via decoration.
AbstractSortedMapDecorator	Provides a base decorator that enables additional functionality to be added to a Map via decoration.
AbstractSortedSetDecorator	Decorates another SortedSet to provide additional behaviour.
AllPredicate	Predicate implementation that returns true if all the predicates return true.
AndPredicate	Predicate implementation that returns true if both the predicates return true.
AnyPredicate	Predicate implementation that returns true if any of the predicates return true.
ArrayIterator	Implements an Iterator over any array.
ArrayListIterator	Implements a ListIterator over an array.
ArrayStack	An implementation of the Stack API that is based on an ArrayList instead of a Vector, so it is not synchronized to protect against multi-threaded access.
Bag	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.
BeanMap	Deprecated. Identical class now available in commons-beanutils (full jar version).
BeanMap.MyMapEntry	Map entry used by BeanMap.
BidiMap	Defines a map that allows bidirectional lookup between key and values.
BinaryHeap	Deprecated. Replaced by PriorityBuffer in buffer subpackage.
BlockingBuffer	Decorates another Buffer to make BlockingBuffer.get() and BlockingBuffer.remove() block when the Buffer is empty.
BooleanComparator	A Comparator for Boolean objects that can sort either true or false first.
BoundedBuffer	Decorates another Buffer to ensure a fixed maximum size.
BoundedCollection	Defines a collection that is bounded in size.
BoundedFifoBuffer	Deprecated. Moved to buffer subpackage.
BoundedFifoBuffer	The BoundedFifoBuffer is a very efficient implementation of Buffer that is of a fixed size.
BoundedMap	Defines a map that is bounded in size.
Buffer	Defines a collection that allows objects to be removed in some well-defined order.
BufferOverflowException	The BufferOverflowException is used when the buffer's capacity has been exceeded.
BufferUnderflowException	The BufferUnderflowException is used when the buffer is already empty.
BufferUtils	Provides utility methods and decorators for Buffer instances.
CaseInsensitiveMap	A case-insensitive Map.
ChainedClosure	Closure implementation that chains the specified closures together.
ChainedTransformer	Transformer implementation that chains the specified transformers together.
CircularFifoBuffer	CircularFifoBuffer is a first in first out buffer with a fixed size that replaces its oldest element if full.
CloneTransformer	Transformer implementation that returns a clone of the input object.
Closure	Defines a functor interface implemented by classes that do something.
ClosureTransformer	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	Provides an ordered iteration over the elements contained in a collection of ordered Iterators.
CollectionUtils	Provides utility methods and decorators for Collection instances.
ComparableComparator	A Comparator that compares Comparable objects.
ComparatorChain	A ComparatorChain is a Comparator that wraps one or more Comparators in sequence.
ComparatorUtils	Provides convenient static utility methods for Comparator objects.
CompositeCollection	Decorates a collection of other collections to provide a single unified view.
CompositeCollection.CollectionMutator	Pluggable strategy to handle changes to the composite.
CompositeMap	Decorates a map of other maps to provide a single unified view.
CompositeMap.MapMutator	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	Decorates a set of other sets to provide a single unified view.
CompositeSet.SetMutator	Define callbacks for mutation operations.
ConstantFactory	Factory implementation that returns the same constant each time.
ConstantTransformer	Transformer implementation that returns the same constant each time.
CursorableLinkedList	Deprecated. Use new version in list subpackage, which has been rewritten and now returns the cursor from the listIterator method.
CursorableLinkedList	A List implementation with a ListIterator that allows concurrent modifications to the underlying list.
CursorableLinkedList.Cursor	An extended ListIterator that allows concurrent changes to the underlying list.
CursorableLinkedList.SubCursor	A cursor for the sublist based on LinkedSubListIterator.
DefaultedMap	Decorates another Map returning a default value if the map does not contain the requested key.
DefaultKeyValue	A mutable KeyValue pair that does not implement Map.Entry.
DefaultMapBag	Deprecated. Moved to bag subpackage as AbstractMapBag.
DefaultMapEntry	Deprecated. Use the version in the keyvalue subpackage.
DefaultMapEntry	A restricted implementation of Map.Entry that prevents the Map.Entry contract from being broken.
DoubleOrderedMap	Deprecated. Replaced by TreeBidiMap in bidimap subpackage.
DualHashBidiMap	Implementation of BidiMap that uses two HashMap instances.
DualTreeBidiMap	Implementation of BidiMap that uses two TreeMap instances.
DualTreeBidiMap.BidiOrderedMapIterator	Inner class MapIterator.
DualTreeBidiMap.ViewMap	Internal sorted map view.
EmptyIterator	Provides an implementation of an empty iterator.
EmptyListIterator	Provides an implementation of an empty list iterator.
EmptyMapIterator	Provides an implementation of an empty map iterator.
EmptyOrderedIterator	Provides an implementation of an empty ordered iterator.
EmptyOrderedMapIterator	Provides an implementation of an empty ordered map iterator.
EntrySetMapIterator	Implements a MapIterator using a Map entrySet.
EnumerationIterator	Adapter to make Enumeration instances appear to be Iterator instances.
EnumerationUtils	Provides utility methods for Enumeration instances.
EqualPredicate	Predicate implementation that returns true if the input is the same object as the one stored in this predicate by equals.
ExceptionClosure	Closure implementation that always throws an exception.
ExceptionFactory	Factory implementation that always throws an exception.
ExceptionPredicate	Predicate implementation that always throws an exception.
ExceptionTransformer	Transformer implementation that always throws an exception.
ExtendedProperties	This class extends normal Java properties by adding the possibility to use the same key many times concatenating the value strings instead of overwriting them.
Factory	Defines a functor interface implemented by classes that create objects.
FactoryTransformer	Transformer implementation that calls a Factory and returns the result.
FactoryUtils	FactoryUtils provides reference implementations and utilities for the Factory functor interface.
FalsePredicate	Predicate implementation that always returns false.
FastArrayList	A customized implementation of java.util.ArrayList designed to operate in a multithreaded environment where the large majority of method calls are read-only, instead of structural changes.
FastHashMap	A customized implementation of java.util.HashMap designed to operate in a multithreaded environment where the large majority of method calls are read-only, instead of structural changes.
FastTreeMap	A customized implementation of java.util.TreeMap designed to operate in a multithreaded environment where the large majority of method calls are read-only, instead of structural changes.
FilterIterator	Decorates another Iterator using a predicate to filter elements.
FilterListIterator	Decorates another ListIterator using a predicate to filter elements.
FixedOrderComparator	A Comparator which imposes a specific order on a specific set of Objects.
FixedSizeList	Decorates another List to fix the size preventing add/remove.
FixedSizeMap	Decorates another Map to fix the size, preventing add/remove.
FixedSizeSortedMap	Decorates another SortedMap to fix the size blocking add/remove.
Flat3Map	A Map implementation that stores data in simple fields until the size is greater than 3.
ForClosure	Closure implementation that calls another closure n times, like a for loop.
FunctorException	Runtime exception thrown from functors.
GrowthList	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	Implements Bag, using a HashMap to provide the data storage.
HashBag	Deprecated. Moved to bag subpackage and rewritten internally.
HashedMap	A Map implementation that is a general purpose alternative to HashMap.
IdentityMap	A Map implementation that matches keys and values based on == not equals().
IdentityMap.IdentityEntry	HashEntry
IdentityPredicate	Predicate implementation that returns true if the input is the same object as the one stored in this predicate.
IfClosure	Closure implementation acts as an if statement calling one or other closure based on a predicate.
InstanceofPredicate	Predicate implementation that returns true if the input is an instanceof the type stored in this predicate.
InstantiateFactory	Factory implementation that creates a new object instance by reflection.
InstantiateTransformer	Transformer implementation that creates a new object instance by reflection.
InvokerTransformer	Transformer implementation that creates a new object instance by reflection.
IterableMap	Defines a map that can be iterated directly without needing to create an entry set.
IteratorChain	An IteratorChain is an Iterator that wraps a number of Iterators.
IteratorEnumeration	Adapter to make an Iterator instance appear to be an Enumeration instance.
IteratorUtils	Provides static utility methods and decorators for Iterator instances.
KeyValue	Defines a simple key value pair.
LazyList	Decorates another List to create objects in the list on demand.
LazyMap	Decorates another Map to create objects in the map on demand.
LazySortedMap	Decorates another SortedMap to create objects in the map on demand.
LinkedMap	A Map implementation that maintains the order of the entries.
ListIteratorWrapper	Converts an iterator into a list iterator by caching the returned entries.
ListOrderedMap	Decorates a Map to ensure that the order of addition is retained using a List to maintain order.
ListOrderedSet	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.
LoopingIterator	An Iterator that restarts when it reaches the end.
LoopingListIterator	A ListIterator that restarts when it reaches the end or when it reaches the beginning.
LRUMap	Deprecated. Moved to map subpackage.
LRUMap	A Map implementation with a fixed maximum size which removes the least recently used entry if an entry is added when full.
MapBackedSet	Decorates a Map to obtain Set behaviour.
MapIterator	Defines an iterator that operates over a Map.
MapTransformer	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.
MultiHashMap	Deprecated. Class now available as MultiValueMap in map subpackage.
MultiKey	A MultiKey allows multiple map keys to be merged together.
MultiKeyMap	A Map implementation that uses multiple keys to map the value.
MultiMap	Defines a map that holds a collection of values against each key.
MultiValueMap	A MultiValueMap decorates another map, allowing it to have more than one value for a key.
NodeCachingLinkedList	A List implementation that stores a cache of internal Node objects in an effort to reduce wasteful object creation.
NonePredicate	Predicate implementation that returns true if none of the predicates return true.
NOPClosure	Closure implementation that does nothing.
NOPTransformer	Transformer implementation that does nothing.
NotNullPredicate	Predicate implementation that returns true if the input is not null.
NotPredicate	Predicate implementation that returns the opposite of the decorated predicate.
NullComparator	A Comparator that will compare nulls to be either lower or higher than other objects.
NullIsExceptionPredicate	Predicate implementation that throws an exception if the input is null.
NullIsFalsePredicate	Predicate implementation that returns false if the input is null.
NullIsTruePredicate	Predicate implementation that returns true if the input is null.
NullPredicate	Predicate implementation that returns true if the input is null.
ObjectArrayIterator	An Iterator over an array of objects.
ObjectArrayListIterator	Implements a ListIterator over an array of objects.
ObjectGraphIterator	An Iterator that can traverse multiple iterators down an object graph.
OnePredicate	Predicate implementation that returns true if only one of the predicates return true.
OrderedBidiMap	Defines a map that allows bidirectional lookup between key and values and retains and provides access to an ordering.
OrderedIterator	Defines an iterator that operates over an ordered collection.
OrderedMap	Defines a map that maintains order and allows both forward and backward iteration through that order.
OrderedMapIterator	Defines an iterator that operates over an ordered Map.
OrPredicate	Predicate implementation that returns true if either of the predicates return true.
Predicate	Defines a functor interface implemented by classes that perform a predicate test on an object.
PredicatedBag	Decorates another Bag to validate that additions match a specified predicate.
PredicatedBuffer	Decorates another Buffer to validate that additions match a specified predicate.
PredicatedCollection	Decorates another Collection to validate that additions match a specified predicate.
PredicateDecorator	Defines a predicate that decorates one or more other predicates.
PredicatedList	Decorates another List to validate that all additions match a specified predicate.
PredicatedMap	Decorates another Map to validate that additions match a specified predicate.
PredicatedSet	Decorates another Set to validate that all additions match a specified predicate.
PredicatedSortedBag	Decorates another SortedBag to validate that additions match a specified predicate.
PredicatedSortedMap	Decorates another SortedMap to validate that additions match a specified predicate.
PredicatedSortedSet	Decorates another SortedSet to validate that all additions match a specified predicate.
PredicateTransformer	Transformer implementation that calls a Predicate using the input object and then returns the input.
PredicateUtils	PredicateUtils provides reference implementations and utilities for the Predicate functor interface.
PriorityBuffer	Binary heap implementation of Buffer that provides for removal based on Comparator ordering.
PriorityQueue	Deprecated. Replaced by the Buffer interface and implementations in buffer subpackage.
PrototypeFactory	Factory implementation that creates a new instance each time based on a prototype.
ProxyIterator	Deprecated. Use AbstractIteratorDecorator.
ProxyListIterator	Deprecated. Use AbstractListIteratorDecorator.
ProxyMap	Deprecated. Moved to map subpackage as AbstractMapDecorator.
ReferenceIdentityMap	A Map implementation that allows mappings to be removed by the garbage collector and matches keys and values based on == not equals().
ReferenceMap	A Map implementation that allows mappings to be removed by the garbage collector.
ReferenceMap	Deprecated. Moved to map subpackage.
ResettableIterator	Defines an iterator that can be reset back to an initial state.
ResettableListIterator	Defines a list iterator that can be reset back to an initial state.
ReverseComparator	Reverses the order of another comparator by reversing the arguments to its compare method.
ReverseListIterator	Iterates backwards through a List, starting with the last element and continuing to the first.
SequencedHashMap	Deprecated. Replaced by LinkedMap and ListOrderedMap in map subpackage.
SetUniqueList	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.
SingletonIterator	SingletonIterator is an Iterator over a single object instance.
SingletonListIterator	SingletonIterator is an ListIterator over a single object instance.
SingletonMap	A Map implementation that holds a single item and is fixed size.
SortedBag	Defines a type of Bag that maintains a sorted order among its unique representative members.
SortedBidiMap	Defines a map that allows bidirectional lookup between key and values and retains both keys and values in sorted order.
StaticBucketMap	A StaticBucketMap is an efficient, thread-safe implementation of java.util.Map that performs well in in a highly thread-contentious environment.
StaticBucketMap	Deprecated. Moved to map subpackage.
StringValueTransformer	Transformer implementation that returns the result of calling String.valueOf on the input object.
SwitchClosure	Closure implementation calls the closure whose predicate returns true, like a switch statement.
SwitchTransformer	Transformer implementation calls the transformer whose predicate returns true, like a switch statement.
SynchronizedBag	Decorates another Bag to synchronize its behaviour for a multi-threaded environment.
SynchronizedBuffer	Decorates another Buffer to synchronize its behaviour for a multi-threaded environment.
SynchronizedCollection	Decorates another Collection to synchronize its behaviour for a multi-threaded environment.
SynchronizedList	Decorates another List to synchronize its behaviour for a multi-threaded environment.
SynchronizedPriorityQueue	Deprecated. PriorityQueue is replaced by the Buffer interface, see buffer subpackage.
SynchronizedSet	Decorates another Set to synchronize its behaviour for a multi-threaded environment.
SynchronizedSortedBag	Decorates another SortedBag to synchronize its behaviour for a multi-threaded environment.
SynchronizedSortedSet	Decorates another SortedSet to synchronize its behaviour for a multi-threaded environment.
TiedMapEntry	A Map.Entry tied to a map underneath.
TransformedBag	Decorates another Bag to transform objects that are added.
TransformedBuffer	Decorates another Buffer to transform objects that are added.
TransformedCollection	Decorates another Collection to transform objects that are added.
TransformedList	Decorates another List to transform objects that are added.
TransformedMap	Decorates another Map to transform objects that are added.
TransformedPredicate	Predicate implementation that transforms the given object before invoking another Predicate.
TransformedSet	Decorates another Set to transform objects that are added.
TransformedSortedBag	Decorates another SortedBag to transform objects that are added.
TransformedSortedMap	Decorates another SortedMap to transform objects that are added.
TransformedSortedSet	Decorates another SortedSet to transform objects that are added.
Transformer	Defines a functor interface implemented by classes that transform one object into another.
TransformerClosure	Closure implementation that calls a Transformer using the input object and ignore the result.
TransformerPredicate	Predicate implementation that returns the result of a transformer.
TransformerUtils	TransformerUtils provides reference implementations and utilities for the Transformer functor interface.
TransformingComparator	Decorates another Comparator with transformation behavior.
TransformIterator	Decorates an iterator such that each element returned is transformed.
TreeBag	Implements SortedBag, using a TreeMap to provide the data storage.
TreeBag	Deprecated. Moved to bag subpackage and rewritten internally.
TreeBidiMap	Red-Black tree-based implementation of BidiMap where all objects added implement the Comparable interface.
TreeList	A List implementation that is optimised for fast insertions and removals at any index in the list.
TruePredicate	Predicate implementation that always returns true.
TypedBag	Decorates another Bag to validate that elements added are of a specific type.
TypedBuffer	Decorates another Buffer to validate that elements added are of a specific type.
TypedCollection	Decorates a Collection to validate that elements added are of a specific type.
TypedList	Decorates another List to validate that elements added are of a specific type.
TypedMap	Decorates another Map to validate that elements added are of a specific type.
TypedSet	Decorates another Set to validate that elements added are of a specific type.
TypedSortedBag	Decorates another SortedBag to validate that elements added are of a specific type.
TypedSortedMap	Decorates another SortedMap to validate that elements added are of a specific type.
TypedSortedSet	Decorates another SortedSet to validate that elements added are of a specific type.
UnboundedFifoBuffer	UnboundedFifoBuffer is a very efficient implementation of Buffer that can grow to any size.
UnboundedFifoBuffer	Deprecated. Moved to buffer subpackage.
UniqueFilterIterator	A FilterIterator which only returns "unique" Objects.
UniquePredicate	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	Decorates another Bag to ensure it can't be altered.
UnmodifiableBidiMap	Decorates another BidiMap to ensure it can't be altered.
UnmodifiableBoundedCollection	UnmodifiableBoundedCollection decorates another BoundedCollection to ensure it can't be altered.
UnmodifiableBuffer	Decorates another Buffer to ensure it can't be altered.
UnmodifiableCollection	Decorates another Collection to ensure it can't be altered.
UnmodifiableEntrySet	Decorates a map entry Set to ensure it can't be altered.
UnmodifiableIterator	Decorates an iterator such that it cannot be modified.
UnmodifiableList	Decorates another List to ensure it can't be altered.
UnmodifiableListIterator	Decorates a list iterator such that it cannot be modified.
UnmodifiableMap	Decorates another Map to ensure it can't be altered.
UnmodifiableMapEntry	A Map.Entry that throws UnsupportedOperationException when setValue is called.
UnmodifiableMapIterator	Decorates a map iterator such that it cannot be modified.
UnmodifiableOrderedBidiMap	Decorates another OrderedBidiMap to ensure it can't be altered.
UnmodifiableOrderedMap	Decorates another OrderedMap to ensure it can't be altered.
UnmodifiableOrderedMapIterator	Decorates an ordered map iterator such that it cannot be modified.
UnmodifiableSet	Decorates another Set to ensure it can't be altered.
UnmodifiableSortedBag	Decorates another SortedBag to ensure it can't be altered.
UnmodifiableSortedBidiMap	Decorates another SortedBidiMap to ensure it can't be altered.
UnmodifiableSortedMap	Decorates another SortedMap to ensure it can't be altered.
UnmodifiableSortedSet	Decorates another SortedSet to ensure it can't be altered.
WhileClosure	Closure implementation that executes a closure repeatedly until a condition is met, like a do-while or while loop.