|
|||||||||||
| PREV NEXT | FRAMES NO FRAMES | ||||||||||
Bag to provide additional behaviour.Buffer to provide additional behaviour.Collection to provide additional behaviour.BidiMap implemented using two maps.List to provide additional behaviour.Bag interface to simplify the creation
of subclass implementations.Set to provide additional behaviour.SortedBag to provide additional behaviour.SortedSet to provide additional behaviour.UnsupportedOperationException.
ListIterator.add(Object) method.
UnsupportedOperationException when this method is invoked.
UnsupportedOperationException.
UnsupportedOperationException when this method is invoked.
nCopies copies of the specified object to the Bag.
DefaultMapBag.add(Object) for each element in the given collection.
Collection's Iterator.
AbstractMapBag.add(Object) for each element in the given collection.
Iterator to the iterators being collated.
Iterator over any array.setArray.
ListIterator over an array.setArray.
Stack API that is based on an
ArrayList instead of a Vector, so it is not
synchronized to protect against multi-threaded access.ArrayStack.
ArrayStack with an initial size.
Runnable executes.
Runnable executes.
Bag and SortedBag instances.BeanMap.
BeanMap that operates on the
specified bean.
BinaryHeap.
BinaryHeap that will use the given
comparator to order its elements.
BinaryHeap.
BinaryHeap.
Buffer to make BlockingBuffer.get() and
BlockingBuffer.remove() block when the Buffer is empty.Buffer.get() and Buffer.remove() operations.
Comparator for Boolean objects that can sort either
true or false first.BooleanComparator that sorts
false values before true values.
BooleanComparator that sorts
trueFirst values before
!trueFirst values.
BoundedFifoBuffer big enough to hold
32 elements.
BoundedFifoBuffer big enough to hold
32 elements.
BoundedFifoBuffer big enough to hold all
of the elements in the specified collection.
BoundedFifoBuffer big enough to hold all
of the elements in the specified collection.
BoundedFifoBuffer big enough to hold
the specified number of elements.
BoundedFifoBuffer big enough to hold
the specified number of elements.
BufferOverflowException.
BufferOverflowException.
BufferOverflowException.
BufferUnderflowException.
BufferUnderflowException.
BufferUnderflowException.
Buffer instances.BufferUtils should not normally be instantiated.
Map.Comparators,
applied in (default iterator) sequence until one returns not equal or the
collection is exhausted.
Comparators, applied
in sequence until one returns not equal or the array is exhausted.
Comparators.
Iterators
one after another.
Iterators
one after another.
Iterators
one after another.
Map.clear().
Map.clear().
Map.clear() method.
clear() on all composited Maps.
FastTreeMap instance.
FastHashMap instance.
FastArrayList instance.
ClosureUtils provides reference implementations and utilities
for the Closure functor interface.Iterators.
Iterators.
Iterators.
CollatingIterator.
CollatingIterator that will used the
specified comparator for ordering.
CollatingIterator that will use the
specified comparator to provide ordered iteration over the collection
of iterators.
CollatingIterator that will used the
specified comparator for ordering and have the specified initial
capacity.
CollatingIterator that will use the
specified comparator to provide ordered iteration over the array
of iterators.
CollatingIterator that will use the
specified comparator to provide ordered iteration over the two
given iterators.
Collection instances.CollectionUtils should not normally be instantiated.
Comparator that compares
Comparable objects.null
if this map uses its keys' natural order.
Comparator
objects.null Boolean objects
according to the value of #trueFirst.
Comparable arguments.
set composited
true if this list contains the specified element.
true if the bag contains all elements in
the given collection, respecting cardinality.
true if this list contains all of the elements
in the specified Collection.
true if the bag contains all elements in
the given collection, respecting cardinality.
true iff at least one element is in both collections.
Map.containsKey(Object).
Map.containsKey(Object).
true if this map contains the given key.
Map.containsKey(Object) method.
true if this map contains a mapping for the
specified key.
true if this map contains a mapping for the
specified key.
Map.containsValue(Object).
Map.containsValue(Object).
Map.containsValue(Object) method.
true if this map contains one or more keys mapping
to the specified value.
true if this map contains one or more keys mapping
to the specified value.
ListIterator for iterating through the
elements of this list.
CursorableLinkedList.Cursor for iterating through the elements of this list.
ListIterator for iterating through the
elements of this list, initialized such that
ListIterator.next() will return the element at
the specified index (if any) and ListIterator.previous()
will return the element immediately preceding it (if any).
CursorableLinkedList.Cursor for iterating through the elements of this list
starting from a specified index.
List implementation with a ListIterator that
allows concurrent modifications to the underlying list.ListIterator that allows concurrent changes to
the underlying list.Map.Entry that prevents
the MapEntry contract from being broken.DefaultMapEntry with a null key
and null value.
DefaultMapEntry with the given
key and given value.
DefaultMapEntry with the given
key and given value.
Collection containing the exclusive disjunction
(symmetric difference) of the given Collections.
BidiMap that uses two HashMap instances.HashBidiMap.
HashBidiMap and copies the mappings from
specified Map.
BidiMap that uses two TreeMap instances.DualTreeBidiMap
DualTreeBidiMap using the specified Comparator.
DualTreeBidiMap and copies the mappings from
specified Map.
true if this stack is currently empty.
ArrayList instance, if
necessary, to ensure that it can hold at least the number of elements
specified by the minimum capacity argument.
Map.entrySet().
Map.entrySet().
Map.entrySet() method.
MapIterator using a Map entrySet.Enumeration instances appear
to be Iterator instances.EnumerationIterator that will not
function until EnumerationIterator.setEnumeration(Enumeration) is called.
EnumerationIterator that provides
an iterator view of the given enumeration.
EnumerationIterator that will remove
elements from the specified collection.
Enumeration instances.Map.equals(Object).
Map.equals(Object).
Map.equals(Object) method.
true iff that Object is
is a Comparator whose ordering is known to be
equivalent to mine.
true iff that Object is
is a Comparator whose ordering is known to be
equivalent to mine.
true iff that Object is
is a Comparator whose ordering is
known to be equivalent to mine.
true iff that Object is
is a Comparator whose ordering is known to be
equivalent to mine.
count times.
FactoryUtils provides reference implementations and utilities
for the Factory functor interface.java.util.ArrayList designed
to operate in a multithreaded environment where the large majority of
method calls are read-only, instead of structural changes.java.util.HashMap designed
to operate in a multithreaded environment where the large majority of
method calls are read-only, instead of structural changes.java.util.TreeMap designed
to operate in a multithreaded environment where the large majority of
method calls are read-only, instead of structural changes.FilterIterator that will not function
until setIterator is invoked.
FilterIterator that will not function
until setPredicate is invoked.
FilterIterator that will use the
given iterator and predicate.
ListIterator which
takes a Predicate instance to filter
out objects from an underlying ListIterator
instance.FilterListIterator that will not
function until
setListIterator
and setPredicate are invoked.
FilterListIterator that will not
function until setPredicate is invoked.
FilterListIterator.
FilterListIterator that will not
function until
setListIterator
is invoked.
List to fix the size preventing add/remove.Map to fix the size, preventing add/remove.SortedMap to fix the size blocking add/remove.Map implementation that stores data in simple fields until
the size is greater than 3.count times.
FunctorException without specified
detail message.
FunctorException with specified
detail message.
FunctorException with specified
detail message and nested Throwable root cause.
FunctorException with specified
nested Throwable root cause.
Map.get(Object).
Map.get(Object).
Map.get(Object) method.
index-th value in object, throwing
IndexOutOfBoundsException if there is no such element or
IllegalArgumentException if object is not an
instance of one of the supported types.
trueFirst values before
!trueFirst values.
Map mapping each unique element in the given
Collection to an Integer representing the number
of occurrences of that element in the Collection.
Comparator by which collatation occurs.
false values before true values.
next().
next().
true values before false values.
next().
next().
Bag, using a HashMap to provide the
data storage.HashBag.
HashBag.
Bag containing all the members of the given
collection.
Map.hashCode().
Map.hashCode().
Map.hashCode() method.
equals.
NullComparator.equals(Object).
equals.
equals.
equals.
List.hashCode().
Set.hashCode().
Map implementation that is a general purpose alternative
to HashMap.ListIterator.hasNext() method.
true if any child iterator has remaining elements.
ListIterator.hasPrevious() method.
Map implementation that matches keys and values based
on == not equals().CollectionUtils.get(Object, int) instead. Will be removed in v4.0
CollectionUtils.get(Object, int) instead. Will be removed in v4.0
equals() method, and return
the corresponding index, or -1 if the object is not found.
Collection containing the intersection
of the given Collections.
Map.isEmpty().
Map.isEmpty().
true if this map is empty.
Map.isEmpty() method.
true if this map contains no mappings.
true if this map contains no mappings.
Collections contain
exactly the same elements with exactly the same cardinalities.
List.equals(java.lang.Object).
equals() contract
in Set.equals(java.lang.Object).
Iterator over the entire set of members,
including copies due to cardinality.
IteratorChain over the collection
of iterators.
IteratorChain over the array
of iterators.
IteratorChain over the two
given iterators.
Iterator instance appear to be
an Enumeration instance.IteratorEnumeration that will not
function until setIterator is
invoked.
IteratorEnumeration that will use
the given iterator.
Iterator
instances.Map.keySet().
Map.keySet().
Map.keySet() method.
equals() method, and return
the corresponding index, or -1 if the object is not found.
List to create objects in the list on demand.Map to create objects in the map on demand.SortedMap to create objects in the map on demand.Map implementation that maintains the order of the entries.ListIteratorWrapper that will wrap
the given iterator.
Map to ensure that the order of addition is retained
using a List to maintain order.ListOrderedMap that decorates
a HashMap.
Set to ensure that the order of addition
is retained and used by the iterator.ListOrderedSet using
a HashSet and an ArrayList internally.
List instances.ListUtils should not normally be instantiated.
Map implementation with a fixed maximum size which removes
the least recently used entry if an entry is added when full.