All Classes and Interfaces
Class
Description
Decorates another 
Bag to provide additional behavior.Provides a base decorator that enables additional functionality to be added
 to a BidiMap via decoration.
Decorates another 
Collection to provide additional behavior.Abstract 
BidiMap implemented using two maps.Inner class MapIterator.
Inner class EntrySet.
Inner class EntrySetIterator.
Inner class KeySet.
Inner class KeySetIterator.
Inner class MapEntry.
Inner class Values.
Inner class ValuesIterator.
Inner class View.
Provides an implementation of an empty map iterator.
An abstract implementation of a hash-based map which provides numerous points for
 subclasses to override.
EntrySet implementation.
EntrySet iterator.
HashEntry used to store the data.
Base Iterator.
MapIterator implementation.
KeySet implementation.
KeySet iterator.
Values implementation.
Values iterator.
Provide a basic 
IterableMap implementation.Provides basic behavior for decorating an iterator with extra functionality.
Abstract pair class to assist with creating 
KeyValue
 and Map.Entry implementations.Deprecated.
A list iterator over the linked list.
The sublist implementation for AbstractLinkedList.
A list iterator over the linked sub list.
A node within the linked list.
An abstract implementation of a linked list which provides numerous points for
 subclasses to override.
A list iterator over the linked list.
The sublist implementation for AbstractLinkedListJava21.
A list iterator over the linked sub list.
A node within the linked list.
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.
EntrySet iterator.
KeySet iterator.
LinkEntry that stores the data.
Base Iterator that iterates in link order.
MapIterator implementation.
Values iterator.
Decorates another 
List to provide additional behavior.Provides basic behavior for decorating a list iterator with extra functionality.
Abstract implementation of the 
ListValuedMap interface to simplify
 the creation of subclass implementations.Abstract implementation of the 
Bag interface to simplify the creation
 of subclass implementations.Mutable integer class for storing the data.
Provides a base decorator that enables additional functionality to be added
 to a Map via decoration.
Abstract Pair class to assist with creating correct
 
Map.Entry implementations.Provides a base decorator that allows additional functionality to be
 added to a 
Map.Entry.Provides basic behavior for decorating a map iterator with extra functionality.
Abstract implementation of the 
MultiSet interface to simplify the
 creation of subclass implementations.Inner class EntrySetIterator.
Inner class MultiSetEntry.
Mutable integer class for storing the data.
Inner class UniqueSetIterator.
Abstract implementation of the 
MultiSet interface to simplify the
 creation of subclass implementations.Inner class AbstractEntry.
Inner class EntrySet.
Inner class UniqueSet.
Decorates another 
MultiSet to provide additional behavior.Abstract implementation of the 
MultiValuedMap interface to simplify
 the creation of subclass implementations.Decorates another 
MultiValuedMap to provide additional behavior.Decorates another 
NavigableSet to provide additional behavior.Provides a base decorator that enables additional functionality to be added
 to an OrderedBidiMap via decoration.
Provides a base decorator that enables additional functionality to be added
 to an OrderedMap via decoration.
Provides basic behavior for decorating an ordered map iterator with extra functionality.
This class implements the base PATRICIA algorithm and everything that
 is related to the 
Map interface.A 
Trie is a set of AbstractPatriciaTrie.TrieEntry nodes.Abstract base class for predicates.
Enumerates property formats.
Abstract base class for quantification predicates, for example All, Any, None.
Decorates another 
Queue to provide additional behavior.An abstract implementation of a hash-based map that allows the entries to
 be removed by the garbage collector.
A MapEntry implementation for the map.
Enumerates reference types.
Serializable subclass of AbstractListDecorator.
Serializable subclass of AbstractSetDecorator.
Decorates another 
Set to provide additional behavior.Abstract implementation of the 
SetValuedMap interface to simplify the
 creation of subclass implementations.Decorates another 
SortedBag to provide additional behavior.Provides a base decorator that enables additional functionality to be added
 to a SortedBidiMap via decoration.
Provides a base decorator that enables additional functionality to be added
 to a Map via decoration.
OrderedMapIterator implementation.
Decorates another 
SortedSet to provide additional behavior.Provides basic behavior for decorating an iterator with extra functionality without committing the generic type of the Iterator implementation.
Predicate implementation that returns true if all the
 predicates return true.
Predicate implementation that returns true if both the predicates return true.
Predicate implementation that returns true if any of the
 predicates return true.
A counting Bloom filter using an int array to track cells for each enabled bit.
Implements an 
Iterator over any array.Implements a 
ListIterator over an array.Implements a 
ListValuedMap, using a LinkedHashMap to provide data
 storage and ArrayLists as value collections.Deprecated.
use 
ArrayDeque instead (available from Java 1.6)Defines a collection that counts the number of times an object appears in
 the collection.
Defines a map that allows bidirectional lookup between key and values.
Produces bit map longs for a Bloom filter.
Contains functions to convert 
int indices into Bloom filter bit positions and visa versa.The interface that describes a Bloom filter.
Produces Bloom filters from a collection (for example, 
LayeredBloomFilter).A 
Comparator for Boolean objects that can sort either
 true or false first.Defines a collection that is bounded in size.
Decorates another iterator to return elements in a specific range.
Defines a map that is bounded in size.
This iterator creates a Cartesian product of the input iterables,
 equivalent to nested for-loops.
A case-insensitive 
Map.Closure that catches any checked exception and re-throws it as a
 FunctorException runtime exception.Some Bloom filter implementations use a count rather than a bit flag.
Represents an operation that accepts an 
<index, count> pair.Closure implementation that chains the specified closures together.
Transformer implementation that chains the specified transformers together.
CircularFifoQueue is a first-in first-out queue with a fixed size that
 replaces its oldest element if full.
Transformer implementation that returns a clone of the input object.
Deprecated.
Use 
Consumer.Transformer implementation that calls a Closure using the input object
 and then returns the input.
ClosureUtils provides reference implementations and utilities
 for the Closure functor interface.Provides an ordered iteration over the elements contained in a collection of
 ordered Iterators.
Decorates another 
Bag to comply with the Collection contract.Decorates another 
SortedBag to comply with the Collection contract.Provides utility methods and decorators for 
Collection instances.This interface should be implemented by user object to walk
 through 
EditScript objects.A 
Comparator that compares Comparable
 objects.A ComparatorChain is a Comparator that wraps one or more Comparators in
 sequence.
Predicate that compares the input object with the one stored in the predicate using a comparator.
Enumerates the comparator criteria.
Provides convenient static utility methods for 
Comparator
 objects.Decorates a collection of other collections to provide a single unified view.
Pluggable strategy to handle changes to the composite.
Decorates a map of other maps to provide a single unified view.
This interface allows definition for all of the indeterminate
 mutators in a CompositeMap, as well as providing a hook for
 callbacks on key collisions.
Decorates a set of other sets to provide a single unified view.
Defines callbacks for mutation operations.
An advanced hash map supporting configurable garbage collection semantics of keys and values, optional referential-equality, full concurrency of retrievals,
 and adjustable expected concurrency for updates.
Builds new ConcurrentReferenceHashMap instances.
Behavior-changing configuration options for the map
An option specifying which Java reference type should be used to refer to a key and/or value.
Factory implementation that returns the same constant each time.
Transformer implementation that returns the same constant each time.
The interface that describes a Bloom filter that associates a count with each
 bit index rather than a bit.
Deprecated.
parent 
AbstractLinkedList is source incompatible with List methods added in Java 21An extended 
ListIterator that allows concurrent changes to
 the underlying list.A cursor for the sublist based on LinkedSubListIterator.
Decorates another 
Map returning a default value if the map
 does not contain the requested key.Default 
Equator implementation.A mutable 
KeyValue pair that does not implement
 Map.Entry.Command representing the deletion of one object of the first sequence.
Implements 
BidiMap with two LinkedHashMap instances.Inner class MapIterator.
Internal sorted map view.
Abstract base class for all commands used to transform an objects sequence
 into another one.
This class gathers all the 
commands needed to transform
 one objects sequence into another objects sequence.Provides an implementation of an empty iterator.
Provides an implementation of an empty list iterator.
Provides an implementation of an empty map iterator.
Provides an implementation of an empty ordered iterator.
Provides an implementation of an empty ordered map iterator.
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.
Implements a 
MapIterator using a Map entrySet.Adapts a Map entrySet to the MapIterator interface.
Adapter to make 
Enumeration instances appear
 to be Iterator instances.Provides utility methods for 
Enumeration instances.Predicate implementation that returns true if the input is the same object
 as the one stored in this predicate by equals.
An equation function, which determines equality between objects of type T.
Closure implementation that always throws an exception.
Factory implementation that always throws an exception.
Predicate implementation that always throws an exception.
Transformer implementation that always throws an exception.
Extends Iterator functionality to include operations commonly found on streams (for example filtering, concatenating, mapping).
Deprecated.
Use 
Supplier.Transformer implementation that calls a Factory and returns the result.
FactoryUtils provides reference implementations and utilities
 for the Factory functor interface.Predicate implementation that always returns false.
Decorates an 
Iterator using an optional predicate to filter elements.Decorates another 
ListIterator using a predicate to filter elements.A Comparator which imposes a specific order on a specific set of Objects.
Enumerates the unknown object behaviors.
Decorates another 
List to fix the size preventing add/remove.Decorates another 
Map to fix the size, preventing add/remove.Decorates another 
SortedMap to fix the size blocking add/remove.A 
Map implementation that stores data in simple fields until
 the size is greater than 3.A FluentIterable provides a powerful yet simple API for manipulating
 Iterable instances in a fluent manner.
Closure implementation that calls another closure n times, like a for loop.
Runtime exception thrown from functors.
The "read" subset of the 
Map interface.Decorates another 
List to make it seamlessly grow when
 indices larger than the list size are used on add and set,
 avoiding most IndexOutOfBoundsExceptions.Implements 
Bag, using a HashMap to provide the
 data storage.A 
Map implementation that is a general purpose alternative
 to HashMap.A Hasher creates 
IndexExtractors based on the hash implementation and the provided Shape.Implements 
MultiSet, using a HashMap to provide the
 data storage.Predicate implementation that returns true if the input is the same object
 as the one stored in this predicate.
Closure implementation acts as an if statement calling one or other closure
 based on a predicate.
Transformer implementation that will call one of two closures based on whether a predicate evaluates
 as true or false.
An IndexedCollection is a Map-like view onto a Collection.
An object that produces indices of a Bloom filter.
A convenience class for Hasher implementations to filter out duplicate indices.
Command representing the insertion of one object of the second sequence.
Predicate implementation that returns true if the input is an instanceof
 the type stored in this predicate.
Factory implementation that creates a new object instance by reflection.
Transformer implementation that creates a new object instance by reflection.
Transformer implementation that creates a new object instance by reflection.
The "read" subset of the 
Map interface.Defines a map that can be iterated directly without needing to create an entry set.
Provides utility methods and decorators for 
Iterable instances.An IteratorChain is an Iterator that wraps a number of Iterators.
Adapter to make an 
Iterator instance appear to be an
 Enumeration instance.Extends 
Iterator with additional default methods.Provides static utility methods and decorators for 
Iterator
 instances.Command representing the keeping of one object present in both sequences.
Defines the interface to analyze 
Trie keys on a bit level.Defines a simple key value pair.
Layered Bloom filters are described in Zhiwang, Cen; Jungang, Xu; Jian, Sun (2010), "A multi-layer Bloom filter for duplicated URL detection", Proc. 3rd
 International Conference on Advanced Computer Theory and Engineering (ICACTE 2010), vol. 1, pp.
Implementation of the methods to manage the layers in a layered Bloom filter.
Builds new instances of 
LayerManager.Static methods to create a Consumer of a List of BloomFilter perform
 tests on whether to reduce the collection of Bloom filters.
A collection of common ExtendCheck implementations to test whether to extend
 the depth of a LayerManager.
An LazyIteratorChain is an Iterator that wraps a number of Iterators in a lazy manner.
Decorates another 
List to create objects in the list on demand.Decorates another 
Map to create objects in the map on demand.Decorates another 
SortedMap to create objects in the map on demand.Implements a 
SetValuedMap, using a LinkedHashMap to provide data
 storage and LinkedHashSets as value collections.A 
Map implementation that maintains the order of the entries.Converts an 
Iterator into a ResettableListIterator.Decorates a 
Map to ensure that the order of addition is retained
 using a List to maintain order.Decorates another 
Set to ensure that the order of addition is
 retained and used by the iterator.Provides utility methods and decorators for 
List instances.Defines a map that holds a list of values against each key.
Represents a function that accepts a two long-valued argument and produces a binary result.
An Iterator that restarts when it reaches the end.
A ListIterator that restarts when it reaches the end or when it
 reaches the beginning.
A 
Map implementation with a fixed maximum size which removes
 the least recently used entry if an entry is added when full.Decorates a 
Map to obtain Set behavior.Defines an iterator that operates over a 
Map.Transformer implementation that returns the value held in a specified map
 using the input parameter as a key.
A 
MultiKey allows multiple map keys to be merged together.A 
Map implementation that uses multiple keys to map the value.Deprecated.
since 4.1, use 
MultiValuedMap insteadProvides utility methods and decorators for 
MultiValuedMap instances.Defines a collection that counts the number of times an object appears in
 the collection.
An unmodifiable entry for an element and its occurrence as contained in a MultiSet.
Provides utility methods and decorators for 
MultiSet instances.Defines a map that holds a collection of values against each key.
Deprecated.
since 4.1, use 
MultiValuedMap insteadDeprecated.
parent 
AbstractLinkedList is source incompatible with List methods added in Java 21Predicate implementation that returns true if none of the
 predicates return true.
Closure implementation that does nothing.
Transformer implementation that does nothing.
Predicate implementation that returns true if the input is not null.
Predicate implementation that returns the opposite of the decorated predicate.
A Comparator that will compare nulls to be either lower or higher than
 other objects.
Predicate implementation that throws an exception if the input is null.
Predicate implementation that returns false if the input is null.
Predicate implementation that returns true if the input is null.
Predicate implementation that returns true if the input is null.
An 
Iterator over an array of objects.Implements a 
ListIterator over an array of objects.An Iterator that can traverse multiple iterators down an object graph.
Predicate implementation that returns true if only one of the
 predicates return true.
Defines a map that allows bidirectional lookup between key and values
 and retains and provides access to an ordering.
Defines an iterator that operates over an ordered container.
Defines a map that maintains order and allows both forward and backward
 iteration through that order.
Defines an iterator that operates over an ordered 
Map.A drop-in replacement for 
Properties for ordered keys.Creates and loads 
OrderedProperties.Predicate implementation that returns true if either of the predicates return true.
Decorates a 
Map to evict expired entries once their expiration
 time has been reached.A 
ExpirationPolicy
 that returns an expiration time that is a
 constant about of time in the future from the current time.A policy to determine the expiration time for key-value entries.
Implements a PATRICIA Trie (Practical Algorithm to Retrieve Information
 Coded in Alphanumeric).
Decorates an iterator to support one-element lookahead while iterating.
This iterator creates permutations of an input collection, using the
 Steinhaus-Johnson-Trotter algorithm (also called plain changes).
Deprecated.
Use 
Predicate.Decorates another 
Bag to validate that additions
 match a specified predicate.Decorates another 
Collection to validate that additions
 match a specified predicate.Builder for creating predicated collections.
Defines a predicate that decorates one or more other predicates.
Decorates another 
List to validate that all additions
 match a specified predicate.Decorates another 
Map to validate that additions
 match a specified predicate.Decorates another 
MultiSet to validate that additions
 match a specified predicate.Decorates another 
NavigableSet to validate that all additions
 match a specified predicate.Decorates another 
Queue to validate that additions
 match a specified predicate.Decorates another 
Set to validate that all additions
 match a specified predicate.Decorates another 
SortedBag to validate that additions
 match a specified predicate.Decorates another 
SortedMap to validate that additions
 match a specified predicate.Decorates another 
SortedSet to validate that all additions
 match a specified predicate.Transformer implementation that calls a Predicate using the input object
 and then returns the result.
PredicateUtils provides reference implementations and utilities
 for the Predicate functor interface.Creates and loads 
Properties.Factory implementation that creates a new instance each time based on a prototype.
Decorates an iterator to support pushback of elements.
The "write" subset of the 
Map interface.Provides utility methods and decorators for 
Queue instances.A 
Map implementation that allows mappings to be
 removed by the garbage collector and matches keys and values based
 on == not equals().A 
Map implementation that allows mappings to be
 removed by the garbage collector.This class handles sequences of replacements resulting from a comparison.
This interface is devoted to handle synchronized replacement sequences.
Defines an iterator that can be reset back to an initial state.
Defines a list iterator that can be reset back to an initial state.
Reverses the order of another comparator by reversing the arguments
 to its 
compare method.Iterates backwards through a List, starting with the last element
 and continuing to the first.
This class allows to compare two objects sequences.
Implementations of set operations on BitMapExtractors.
Decorates a 
List to ensure that no duplicates are present much
 like a Set.An unmodifiable view of a set that may be backed by other sets.
Defines a map that holds a set of values against each key.
The definition of a Bloom filter shape.
A bloom filter using an array of bit maps to track enabled bits.
SingletonIterator is an Iterator over a single
 object instance.SingletonIterator is an ListIterator over a single
 object instance.A 
Map implementation that holds a single item and is fixed size.Decorates another iterator to skip the first N elements.
Defines a type of 
Bag that maintains a sorted order among
 its unique representative members.Defines a map that allows bidirectional lookup between key and values
 and retains both keys and values in sorted order.
A drop-in replacement for 
Properties for sorting keys.Creates and loads 
SortedProperties.A bloom filter using a TreeSet of integers to track enabled bits.
A StaticBucketMap is an efficient, thread-safe implementation of
 
Map that performs well in a highly
 thread-contentious environment.An 
KeyAnalyzer for Strings.Transformer implementation that returns the result of calling
 
String.valueOf on the input object.Closure implementation calls the closure whose predicate returns true,
 like a switch statement.
Transformer implementation calls the transformer whose predicate returns true,
 like a switch statement.
Decorates another 
Bag to synchronize its behavior
 for a multithreaded environment.Decorates another 
Collection to synchronize its behavior
 for a multithreaded environment.Decorates another 
MultiSet to synchronize its behavior
 for a multithreaded environment.Decorates another 
Queue to synchronize its behavior for a multithreaded environment.Decorates another 
SortedBag to synchronize its behavior
 for a multithreaded environment.A 
Map.Entry tied to a map underneath.Decorates another 
Bag to transform objects that are added.Decorates another 
Collection to transform objects that are added.Decorates another 
List to transform objects that are added.Decorates another 
Map to transform objects that are added.Decorates another 
MultiValuedMap to transform objects that are added.Decorates another 
NavigableSet to transform objects that are added.Predicate implementation that transforms the given object before invoking
 another 
Predicate.Decorates another 
Queue to transform objects that are added.Decorates another 
Set to transform objects that are added.Decorates another 
SortedBag to transform objects that are added.Decorates another 
SortedMap  to transform objects that are added.Decorates another 
SortedSet to transform objects that are added.Decorates another 
Map to transform objects that are added.Deprecated.
Use 
Function.Closure implementation that calls a Transformer using the input object
 and ignore the result.
Predicate implementation that returns the result of a transformer.
TransformerUtils provides reference implementations and
 utilities for the Transformer functor interface.Decorates another Comparator with transformation behavior.
Decorates an iterator such that each element returned is transformed.
Red-Black tree-based implementation of BidiMap where all objects added
 implement the 
Comparable interface.A 
List implementation that is optimized for fast insertions and
 removals at any index in the list.Defines the interface for a prefix tree, an ordered tree data structure.
A collection of 
Trie utilities.Predicate implementation that always returns true.
A FilterIterator which only returns "unique" Objects.
Predicate implementation that returns true the first time an object is
 passed into the predicate.
Marker interface for collections, maps and iterators that are unmodifiable.
Decorates another 
Bag to ensure it can't be altered.Decorates another 
BidiMap to ensure it can't be altered.UnmodifiableBoundedCollection decorates another
 BoundedCollection to ensure it can't be altered.Decorates another 
Collection to ensure it can't be altered.Decorates a map entry 
Set to ensure it can't be altered.Decorates an iterator such that it cannot be modified.
Decorates another 
List to ensure it can't be altered.Decorates a list iterator such that it cannot be modified.
Decorates another 
Map to ensure it can't be altered.A 
Map.Entry that throws
 UnsupportedOperationException when setValue is called.Decorates a map iterator such that it cannot be modified.
Decorates another 
MultiSet to ensure it can't be altered.Decorates another 
MultiValuedMap to ensure it can't be altered.Decorates another 
NavigableSet to ensure it can't be altered.Decorates another 
OrderedBidiMap to ensure it can't be altered.Decorates another 
OrderedMap to ensure it can't be altered.Decorates an ordered map iterator such that it cannot be modified.
Decorates another 
Queue to ensure it can't be altered.Decorates another 
Set to ensure it can't be altered.Decorates another 
SortedBag to ensure it can't be altered.Decorates another 
SortedBidiMap to ensure it can't be altered.Decorates another 
SortedMap to ensure it can't be altered.Decorates another 
SortedSet to ensure it can't be altered.An unmodifiable 
Trie.Closure implementation that executes a closure repeatedly until a condition is met,
 like a do-while or while loop.
An abstract class to assist in implementing Bloom filter decorators.
Provides an interleaved iteration over the elements contained in a
 collection of Iterators.
AbstractLinkedListJava21instead