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