Class Index

A B C D E F G H I K L M N O P R S T U W

A

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 java.util.Map.Entry 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 java.util.Map.Entry Map.Entry implementations.
AbstractMapEntryDecorator	Provides a base decorator that allows additional functionality to be added to a java.util.Map.Entry 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 java.util.Iterator Iterator over any array.
ArrayListIterator	Implements a ListIterator over an array.
ArrayStack	An implementation of the java.util.Stack API that is based on an `ArrayList` instead of a `Vector`, so it is not synchronized to protect against multi-threaded access.

B

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	This class is deprecated. Identical class now available in commons-beanutils (full jar version). This version is due to be removed in collections v4.0.
BeanMap.MyMapEntry	Map entry used by `BeanMap`.
BidiMap	Defines a map that allows bidirectional lookup between key and values.
BinaryHeap	This class is deprecated. Replaced by PriorityBuffer in buffer subpackage. Due to be removed in v4.0.
BlockingBuffer	Decorates another `Buffer` to make `get()` and `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	This class is deprecated. Moved to buffer subpackage. Due to be removed in v4.0.
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.

C

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 Comparator that compares Comparable 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	This class is deprecated. Use new version in list subpackage, which has been rewritten and now returns the cursor from the listIterator method. Will be removed in v4.0
CursorableLinkedList	A `List` implementation with a `ListIterator` that allows concurrent modifications to the underlying list.
CursorableLinkedList.Cursor
CursorableLinkedList.Cursor	An extended `ListIterator` that allows concurrent changes to the underlying list.
CursorableLinkedList.SubCursor	A cursor for the sublist based on LinkedSubListIterator.

D

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 java.util.Map.Entry Map.Entry.
DefaultMapBag	This class is deprecated. Moved to bag subpackage as AbstractMapBag. Due to be removed in v4.0.
DefaultMapEntry	This class is deprecated. Use the version in the keyvalue subpackage. Will be removed in v4.0
DefaultMapEntry	A restricted implementation of java.util.Map.Entry that prevents the `Map.Entry` contract from being broken.
DoubleOrderedMap	This class is deprecated. Replaced by TreeBidiMap in bidimap subpackage. Due to be removed in v4.0.
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.

E

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 Enumeration instances appear to be Iterator 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.

F

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.

G

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.

H

HashBag	This class is deprecated. Moved to bag subpackage and rewritten internally. Due to be removed in v4.0.
HashBag	Implements `Bag`, using a `HashMap` to provide the data storage.
HashedMap	A `Map` implementation that is a general purpose alternative to `HashMap`.

I

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 Iterator instance appear to be an Enumeration Enumeration instance.
IteratorUtils	Provides static utility methods and decorators for Iterator instances.

K

KeyValue Defines a simple key value pair.

L

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	This class is deprecated. Moved to map subpackage. Due to be removed in v4.0.
LRUMap	A `Map` implementation with a fixed maximum size which removes the least recently used entry if an entry is added when full.

M

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	This class is deprecated. Class now available as MultiValueMap in map subpackage. This version is due to be removed in collections v4.0.
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.

N

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.

O

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.

P

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.
PredicatedList.PredicatedListIterator	Inner class Iterator for the PredicatedList
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	This interface is deprecated. Replaced by the Buffer interface and implementations in buffer subpackage. Due to be removed in v4.0.
PrototypeFactory	Factory implementation that creates a new instance each time based on a prototype.
ProxyIterator	This class is deprecated. Use AbstractIteratorDecorator. Will be removed in v4.0
ProxyListIterator	This class is deprecated. Use AbstractListIteratorDecorator. Will be removed in v4.0
ProxyMap	This class is deprecated. Moved to map subpackage as AbstractMapDecorator. It will be removed in v4.0.

R

ReferenceIdentityMap	A `Map` implementation that allows mappings to be removed by the garbage collector and matches keys and values based on `==` not `equals()`.
ReferenceMap	This class is deprecated. Moved to map subpackage. Due to be removed in v4.0.
ReferenceMap	A `Map` implementation that allows mappings to be removed by the garbage collector.
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.

S

SequencedHashMap	This class is deprecated. Replaced by LinkedMap and ListOrderedMap in map subpackage. Due to be removed in v4.0.
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	This class is deprecated. Moved to map subpackage. Due to be removed in v4.0.
StaticBucketMap	A StaticBucketMap is an efficient, thread-safe implementation of `java.util.Map` that performs well in in a highly thread-contentious environment.
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	This class is deprecated. PriorityQueue is replaced by the Buffer interface, see buffer subpackage. Due to be removed in v4.0.
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.

T

TiedMapEntry	A java.util.Map.Entry 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.
TransformedList.TransformedListIterator	Inner class Iterator for the TransformedList
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	This class is deprecated. Moved to bag subpackage and rewritten internally. Due to be removed in v4.0.
TreeBag	Implements `SortedBag`, using a `TreeMap` to provide the data storage.
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.

U

UnboundedFifoBuffer	This class is deprecated. Moved to buffer subpackage. Due to be removed in v4.0.
UnboundedFifoBuffer	UnboundedFifoBuffer is a very efficient implementation of `Buffer` that can grow to any size.
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 java.util.Map.Entry 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.

W

WhileClosure Closure implementation that executes a closure repeatedly until a condition is met, like a do-while or while loop.