All Classes and Interfaces (Apache Commons Collections 4.4 API)

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 behaviour.

AbstractListIteratorDecorator<E>

Provides basic behaviour 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 behaviour 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 MultSet to provide additional behaviour.

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 behaviour.

AbstractNavigableSetDecorator<E>

Decorates another NavigableSet to provide additional behaviour.

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 behaviour for decorating an ordered map iterator with extra functionality.

AbstractPropertiesFactory<T extends Properties>

Subclasses create and load Properties and subclasses of Properties like SortedProperties.

AbstractQuantifierPredicate<T>

Abstract base class for quantification predicates, e.g.

AbstractQueueDecorator<E>

Decorates another Queue to provide additional behaviour.

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 behaviour.

AbstractSetValuedMap<K,V>

Abstract implementation of the SetValuedMap interface to simplify the creation of subclass implementations.

AbstractSortedBagDecorator<E>

Decorates another SortedBag to provide additional behaviour.

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 behaviour.

AbstractUntypedIteratorDecorator<I,O>

Provides basic behaviour 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.

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.

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.

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>

Define 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.

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.

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.

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.

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.

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.

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 behaviour.

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.

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 a 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<E>

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.

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.

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.

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 java.util.Map that performs well in 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 behaviour for a multi-threaded environment.

SynchronizedCollection<E>

Decorates another Collection to synchronize its behaviour for a multi-threaded environment.

SynchronizedMultiSet<E>

Decorates another MultiSet to synchronize its behaviour for a multi-threaded environment.

SynchronizedQueue<E>

Decorates another Queue to synchronize its behaviour for a multi-threaded environment.

SynchronizedSortedBag<E>

Decorates another SortedBag to synchronize its behaviour for a multi-threaded 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 optimised 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.

ZippingIterator<E>

Provides an interleaved iteration over the elements contained in a collection of Iterators.