|
|||||||||||
| 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.createMap.
createBidiMap implementation.
KeyValue
and Map.Entry implementations.List to provide additional behaviour.Bag interface to simplify the creation
of subclass implementations.Map.Entry implementations.Map.Entry.Set to provide additional behaviour.SortedBag to provide additional behaviour.SortedSet to provide additional behaviour.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.
nCopies copies of the specified object to the Bag.
UnsupportedOperationException when this method is invoked.
UnsupportedOperationException.
UnsupportedOperationException when this method is invoked.
ListIterator.add(Object) method.
UnsupportedOperationException.
Collection's Iterator.
DefaultMapBag.add(Object) for each element in the given collection.
AbstractMapBag.add(Object) for each element in the given collection.
Iterator to the iterators being collated.
value and inserts it after node.
value and inserts it before node.
Runnable executes.
Runnable executes.
Bag and SortedBag instances.BeanMap.
BeanMap that operates on the
specified bean.
BeanMap.MyMapEntry.
BinaryHeap that will use the given
comparator to order its elements.
BinaryHeap.
BinaryHeap.
BinaryHeap.
Buffer to make BlockingBuffer.get() and
BlockingBuffer.remove() block when the Buffer is empty.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.
Buffer to ensure a fixed maximum size.BoundedFifoBuffer big enough to hold
32 elements.
BoundedFifoBuffer big enough to hold
the specified number of elements.
BoundedFifoBuffer big enough to hold all
of the elements in the specified collection.
Buffer that is of a fixed size.BoundedFifoBuffer big enough to hold
32 elements.
BoundedFifoBuffer big enough to hold
the specified number of elements.
BoundedFifoBuffer big enough to hold all
of the elements in the specified collection.
BufferOverflowException.
BufferOverflowException.
BufferOverflowException.
BufferUnderflowException.
BufferUnderflowException.
BufferUnderflowException.
Buffer instances.BufferUtils should not normally be instantiated.
Buffer.get() and Buffer.remove() operations.
Buffer.get() and Buffer.remove() operations
until timeout expires.
Collection.add(Object) and
Collection.addAll(java.util.Collection) until enough object(s) are
removed from the buffer to allow the object(s) to be added and still
maintain the maximum size.
Collection.add(Object) and
Collection.addAll(java.util.Collection) until enough object(s) are
removed from the buffer to allow the object(s) to be added and still
maintain the maximum size or the timeout expires.
Map.ClosureUtils provides reference implementations and utilities
for the Closure functor interface.CollatingIterator.
CollatingIterator that will used the
specified comparator for ordering.
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 two
given iterators.
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 collection
of iterators.
Collection instances.CollectionUtils should not normally be instantiated.
Comparator that compares
Comparable objects.Comparator
objects.set composited
List implementation with a ListIterator that
allows concurrent modifications to the underlying list.ListIterator that allows concurrent changes to
the underlying list.Comparators.
Comparators, applied
in sequence until one returns not equal or the array is exhausted.
Comparators,
applied in (default iterator) sequence until one returns not equal or the
collection is exhausted.
Iterators
one after another.
Iterators
one after another.
Iterators
one after another.
setValue.
setValue.
Map.clear() method.
Map.clear().
Map.clear().
clear() on all composited Maps.
FastArrayList instance.
FastHashMap instance.
FastTreeMap instance.
Iterators.
Iterators.
Iterators.
null
if this map uses its keys' natural order.
null Boolean objects
according to the value of BooleanComparator.sortsTrueFirst().
Comparable arguments.
true if this list contains the specified element.
true if the bag contains all elements in
the given collection, respecting cardinality.
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 iff at least one element is in both collections.
true if this map contains a mapping for the
specified key.
true if this map contains a mapping for the
specified key.
Map.containsKey(Object) method.
true if this map contains the given key.
Map.containsKey(Object).
Map.containsKey(Object).
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.
Map.containsValue(Object) method.
Map.containsValue(Object).
Map.containsValue(Object).
AbstractHashedMap to convert keys to
lower case.
AbstractLinkedList.LinkedListIterator.next() or AbstractLinkedList.LinkedListIterator.previous().
ListIterator 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.
CursorableLinkedList.Cursor for iterating through the elements of this list
starting from a specified index.
NodeCachingLinkedList.maximumCacheSize.
KeyValue pair that does not implement
Map.Entry.KeyValue.
Map.Entry.
DefaultMapEntry with a null key
and null value.
DefaultMapEntry with the given
key and given value.
DefaultMapEntry with the given
key and given value.
Map.Entry that prevents
the Map.Entry contract from being broken.KeyValue.
Map.Entry.
Map returning a default value if the map
does not contain the requested key.DefaultedMap that decorates
a HashMap.
BidiMap that uses two HashMap instances.HashBidiMap.
HashBidiMap and copies the mappings from
specified Map.
HashBidiMap that decorates the specified maps.
BidiMap that uses two TreeMap instances.DualTreeBidiMap
DualTreeBidiMap and copies the mappings from
specified Map.
DualTreeBidiMap using the specified Comparator.
DualTreeBidiMap that decorates the specified maps.
map and
maps keys to collections of type collectionClass.
map and
creates the value collections using the supplied collectionFactory.
Collection containing the exclusive disjunction
(symmetric difference) of the given Collections.
put() to work in the superclass.
put() to work in deserialization.
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.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.Entry to decorate
after field from a LinkEntry.
before field from a LinkEntry.
hashCode field from a HashEntry.
key field from a HashEntry.
next field from a HashEntry.
Map.entrySet() method.
Map.entrySet().
Map.entrySet().
value field from a HashEntry.
Map.equals(Object) method.
Map.equals(Object).
Map.equals(Object).
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.
Map.Entry with another Map.Entry.
Map.Entry with another Map.Entry.
Map.Entry with another Map.Entry.
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.Iterator using a predicate to filter elements.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 using a predicate to filter elements.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.FunctorException without specified
detail message.
FunctorException with specified
detail message.
FunctorException with specified
nested Throwable root cause.
FunctorException with specified
detail message and nested Throwable root cause.
BeanMap.put(Object,Object) operation.
null if no nodes are cached.
count times.
List to make it seamlessly grow when
indices larger than the list size are used on add and set,
avoiding most IndexOutOfBoundsExceptions.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.
Map.get(Object) method.
Map.get(Object).
Map.get(Object).
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.