All Classes and Interfaces (Apache Commons Collections 4.2 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.

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.

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.

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.