All Classes and Interfaces

Class	Description
AbstractBagDecorator<E>	Decorates another Bag to provide additional behavior.
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 behavior.
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 behavior 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 behavior.
AbstractListIteratorDecorator<E>	Provides basic behavior 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 behavior 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 MultiSet to provide additional behavior.
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 behavior.
AbstractNavigableSetDecorator<E>	Decorates another NavigableSet to provide additional behavior.
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 behavior for decorating an ordered map iterator with extra functionality.
AbstractPatriciaTrie<K,V>	This class implements the base PATRICIA algorithm and everything that is related to the Map interface.
AbstractPatriciaTrie.TrieEntry<K,V>	A Trie is a set of AbstractPatriciaTrie.TrieEntry nodes.
AbstractPropertiesFactory<T extends Properties>	Subclasses create and load Properties and subclasses of Properties like SortedProperties.
AbstractPropertiesFactory.PropertyFormat	Enumerates property formats.
AbstractQuantifierPredicate<T>	Abstract base class for quantification predicates, e.g.
AbstractQueueDecorator<E>	Decorates another Queue to provide additional behavior.
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 behavior.
AbstractSetValuedMap<K,V>	Abstract implementation of the SetValuedMap interface to simplify the creation of subclass implementations.
AbstractSortedBagDecorator<E>	Decorates another SortedBag to provide additional behavior.
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 behavior.
AbstractUntypedIteratorDecorator<I,O>	Provides basic behavior 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.
ArrayCountingBloomFilter	A counting Bloom filter using an int array to track cells for each enabled bit.
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.
BitMap	Contains functions to convert int indices into Bloom filter bit positions and visa versa.
BitMapProducer	Produces bit map longs for a Bloom filter.
BloomFilter	The interface that describes a Bloom filter.
BloomFilterProducer	Produces Bloom filters from a collection (e.g.
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.
CellProducer	Some Bloom filter implementations use a count rather than a bit flag.
CellProducer.CellConsumer	Represents an operation that accepts an <index, count> pair.
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>	Defines 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.
CountingBloomFilter	The interface that describes a Bloom filter that associates a count with each bit index rather than a bit.
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.
EnhancedDoubleHasher	A Hasher that implements combinatorial hashing as described by Krisch and Mitzenmacher using the enhanced double hashing technique described in the wikipedia article Double Hashing.
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.
Hasher	A Hasher creates IndexProducer based on the hash implementation and the provided Shape.
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.
IndexFilter	A convenience class for Hasher implementations to filter out duplicate indices.
IndexProducer	An object that produces indices of a Bloom filter.
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.
LayeredBloomFilter	Layered Bloom filters are described in Zhiwang, Cen; Jungang, Xu; Jian, Sun (2010), "A multi-layer Bloom filter for duplicated URL detection", Proc.
LayerManager	Implementation of the methods to manage the layers in a layered Bloom filter.
LayerManager.Builder	Builder to create Layer Manager
LayerManager.Cleanup	Static methods to create a Consumer of a LinkedList of BloomFilter perform tests on whether to reduce the collection of Bloom filters.
LayerManager.ExtendCheck	A collection of common ExtendCheck implementations to test whether to extend the depth of a LayerManager.
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.
LongBiPredicate	Represents a function that accepts a two long-valued argument and produces a binary result.
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 behavior.
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.
OrderedProperties	A drop-in replacement for Properties for ordered keys.
OrderedPropertiesFactory	Creates and loads OrderedProperties.
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 an 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<V>	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.
PropertiesFactory	Creates and loads Properties.
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.
SetOperations	Implementations of set operations on BitMapProducers.
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.
Shape	The definition of a Bloom filter shape.
SimpleBloomFilter	A bloom filter using an array of bit maps to track enabled bits.
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.
SortedPropertiesFactory	Creates and loads SortedProperties.
SparseBloomFilter	A bloom filter using a TreeSet of integers to track enabled bits.
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 Map that performs well 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 behavior for a multithreaded environment.
SynchronizedCollection<E>	Decorates another Collection to synchronize its behavior for a multithreaded environment.
SynchronizedMultiSet<E>	Decorates another MultiSet to synchronize its behavior for a multithreaded environment.
SynchronizedQueue<E>	Decorates another Queue to synchronize its behavior for a multithreaded environment.
SynchronizedSortedBag<E>	Decorates another SortedBag to synchronize its behavior for a multithreaded 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 optimized 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.
WrappedBloomFilter	An abstract class to assist in implementing Bloom filter decorators.
ZippingIterator<E>	Provides an interleaved iteration over the elements contained in a collection of Iterators.