# 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>
Deprecated.
use `AbstractLinkedListJava21` instead
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.
AbstractLinkedListJava21<E>
An abstract implementation of a linked list which provides numerous points for subclasses to override.
AbstractLinkedListJava21.LinkedListIterator<E>
A list iterator over the linked list.
AbstractLinkedListJava21.LinkedSubList<E>
The sublist implementation for AbstractLinkedListJava21.
AbstractLinkedListJava21.LinkedSubListIterator<E>
A list iterator over the linked sub list.
AbstractLinkedListJava21.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.
AbstractPredicate<T>
Abstract base class for predicates.
AbstractPropertiesFactory<T>
Subclasses create and load `Properties` and subclasses of `Properties` like `SortedProperties`.
AbstractPropertiesFactory.PropertyFormat
Enumerates property formats.
AbstractQuantifierPredicate<T>
Abstract base class for quantification predicates, for example All, Any, None.
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
Enumerates reference types.
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 `ArrayList`s as value collections.
ArrayListValuedLinkedHashMap<K,V>
Implements a `ListValuedMap`, using a `LinkedHashMap` to provide data storage and `ArrayList`s 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.
BitMapExtractor
Produces bit map longs for a Bloom filter.
BitMaps
Contains functions to convert `int` indices into Bloom filter bit positions and visa versa.
BloomFilter<T>
The interface that describes a Bloom filter.
BloomFilterExtractor
Produces Bloom filters from a collection (for example, `LayeredBloomFilter`).
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.
CartesianProductIterator<E>
This iterator creates a Cartesian product of the input iterables, equivalent to nested for-loops.
CaseInsensitiveMap<K,V>
A case-insensitive `Map`.
CatchAndRethrowClosure<T>
`Closure` that catches any checked exception and re-throws it as a `FunctorException` runtime exception.
CellExtractor
Some Bloom filter implementations use a count rather than a bit flag.
CellExtractor.CellPredicate
Represents an operation that accepts an `<index, count>` pair.
ChainedClosure<T>
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>
Deprecated.
Use `Consumer`.
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>
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
Enumerates the comparator criteria.
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.
ConcurrentReferenceHashMap<K,V>
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.
ConcurrentReferenceHashMap.Builder<K,V>
Builds new ConcurrentReferenceHashMap instances.
ConcurrentReferenceHashMap.Option
Behavior-changing configuration options for the map
ConcurrentReferenceHashMap.ReferenceType
An option specifying which Java reference type should be used to refer to a key and/or value.
ConstantFactory<T>
Factory implementation that returns the same constant each time.
ConstantTransformer<T,R>
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>
Deprecated.
parent `AbstractLinkedList` is source incompatible with List methods added in Java 21
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>
Implements `BidiMap` with two `HashMap` instances.
DualLinkedHashBidiMap<K,V>
Implements `BidiMap` with two `LinkedHashMap` instances.
DualTreeBidiMap<K,V>
Implements `BidiMap` with 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<T>
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<T,R>
Transformer implementation that always throws an exception.
ExtendedIterator<T>
Extends Iterator functionality to include operations commonly found on streams (for example filtering, concatenating, mapping).
Factory<T>
Deprecated.
Use `Supplier`.
FactoryTransformer<T,R>
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 an `Iterator` using an optional 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
Enumerates the unknown object behaviors.
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<T>
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 `IndexExtractor`s 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 `HashSet`s 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<T>
Closure implementation acts as an if statement calling one or other closure based on a predicate.
IfTransformer<T,R>
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.
IndexExtractor
An object that produces indices of a Bloom filter.
IndexFilter
A convenience class for Hasher implementations to filter out duplicate indices.
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<T,R>
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.
IteratorOperations<E>
Extends `Iterator` with additional default methods.
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<T>
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.
LayerManager<T>
Implementation of the methods to manage the layers in a layered Bloom filter.
LayerManager.Builder<T>
Builds new instances of `LayerManager`.
LayerManager.Cleanup
Static methods to create a Consumer of a List 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.
LinkedHashSetValuedLinkedHashMap<K,V>
Implements a `SetValuedMap`, using a `LinkedHashMap` to provide data storage and `LinkedHashSet`s as value collections.
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<T,R>
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>
Deprecated.
parent `AbstractLinkedList` is source incompatible with List methods added in Java 21
NodeListIterator
An `Iterator` over a `NodeList`.
NonePredicate<T>
Predicate implementation that returns true if none of the predicates return true.
NOPClosure<T>
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>
Implements 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>
Deprecated.
Use `Predicate`.
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 BitMapExtractors.
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 `String`s.
StringValueTransformer<T>
Transformer implementation that returns the result of calling `String.valueOf` on the input object.
SwitchClosure<T>
Closure implementation calls the closure whose predicate returns true, like a switch statement.
SwitchTransformer<T,R>
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<T,R>
Deprecated.
Use `Function`.
TransformerClosure<T>
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,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<T>
Closure implementation that executes a closure repeatedly until a condition is met, like a do-while or while loop.
WrappedBloomFilter<T,W>
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.