|
|||||||||||
| 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.
Comparator by which collatation occurs.
false values before true values.
next().
next().
CursorableLinkedList.Listable
at the specified index.
true values before false values.
next().
next().
HashBag.
Bag containing all the members of the given
collection.
Bag, using a HashMap to provide the
data storage.HashBag.
Map implementation that is a general purpose alternative
to HashMap.true if any child iterator has remaining elements.
ListIterator.hasNext() method.
ListIterator.hasPrevious() method.
Map.hashCode() method.
Map.hashCode().
Map.hashCode().
equals.
equals.
equals.
NullComparator.equals(Object).
equals.
List.hashCode().
Set.hashCode().
AbstractLinkedList.Node which indicates the start and end of the list and does not
hold a value.
Map implementation that matches keys and values based
on == not equals().IteratorChain over the two
given iterators.
IteratorChain over the array
of iterators.
IteratorChain over the collection
of 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.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.
readObject.
readObject.
Collection containing the intersection
of the given Collections.
true if this map contains no mappings.
true if this map contains no mappings.
Map.isEmpty() method.
true if this map is empty.
Map.isEmpty().
Map.isEmpty().
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.
Map.keySet() method.
Map.keySet().
Map.keySet().
Map implementation with a fixed maximum size which removes
the least recently used entry if an entry is added when full.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.
equals() method, and return
the corresponding index, or -1 if the object is not found.
next()
or previous().
next()
or previous().
System.out.
System.out.
System.err.
Map to obtain Set behaviour.Map.Map and SortedMap instances.MapUtils should not normally be instantiated.
MultiKey allows multiple map keys to be merged together.Map implementation that uses multiple keys to map the value.HashedMap.
MultiKeyMap.decorate(AbstractHashedMap).
HashMap and
storing the multiple values in an ArrayList.
map and
creates the value collections using the supplied collectionFactory.
Map to delegate to.
MapIterator over the map.
MapIterator over the map.
MapIterator over the map.
List implementation that stores a cache of internal Node objects
in an effort to reduce wasteful object creation.null higher than any
non-null object it is compared with.
null higher than any
non-null object it is compared with.
null higher or lower than
any non-null object it is compared with.
null higher or lower than
any non-null object it is compared with.
Map.
Map.
ListIterator.next() method.
AbstractLinkedList.LinkedListIterator.next().
LoopingListIterator.next().
ListIterator.nextIndex() method.
AbstractLinkedList.LinkedListIterator.next.
null values.
null values.
Iterator over an array of objects.setArray.
ListIterator over an array of objects.setArray.
Map.OrderedMapIterator over the map.
OrderedMapIterator over the map.
Bag and
SortedBag interfaces.BidiMap,
OrderedBidiMap and
SortedBidiMap interfaces.Buffer interface.Collection interface.Comparator interface.Closure,
Predicate,
Transformer and
Factory interfaces.Iterator interface.List interface.Map,
IterableMap,
OrderedMap and
SortedMap interfaces.Set and
SortedSet interfaces.PredicateUtils provides reference implementations and utilities
for the Predicate functor interface.Bag to validate that additions
match a specified predicate.Buffer to validate that additions
match a specified predicate.Collection to validate that additions
match a specified predicate.List to validate that all additions
match a specified predicate.Map to validate that additions
match a specified predicate.Set to validate that all additions
match a specified predicate.SortedBag to validate that additions
match a specified predicate.SortedMap to validate that additions
match a specified predicate.SortedSet to validate that all additions
match a specified predicate.Buffer that provides for
removal based on Comparator ordering.ProxyIterator that will not function
until ProxyIterator.setIterator(Iterator) is called.
ProxyIterator that will use the
given iterator.
ProxyListIterator that will not
function until setListIterator
is invoked.
ProxyListIterator that will use the
given list iterator.
Map.
ListIterator.previous() method.
ArrayListIterator.previous() is called.
LoopingListIterator.previous().
ObjectArrayListIterator.previous() is called.
ListIterator.previousIndex() method.
Map.put(Object,Object) method.
Map.put(Object, Object).
Map.put(Object, Object).
Map.putAll(Map) method.
Map.putAll(Map)).
Map.putAll(Map).
Map implementation that allows mappings to be
removed by the garbage collector and matches keys and values based
on == not equals().ReferenceIdentityMap that will
use hard references to keys and soft references to values.
ReferenceIdentityMap that will
use the specified types of references.
ReferenceIdentityMap that will
use the specified types of references.
ReferenceIdentityMap with the
specified reference types, load factor and initial capacity.
ReferenceIdentityMap with the
specified reference types, load factor and initial capacity.
ReferenceMap that will
use hard references to keys and soft references to values.
ReferenceMap that will
use the specified types of references.
ReferenceMap that will
use the specified types of references.
ReferenceMap with the
specified reference types, load factor and initial
capacity.
ReferenceMap with the
specified reference types, load factor and initial
capacity.
Map implementation that allows mappings to be
removed by the garbage collector.ReferenceMap that will
use hard references to keys and soft references to values.
ReferenceMap that will
use the specified types of references.
ReferenceMap that will
use the specified types of references.
ReferenceMap with the
specified reference types, load factor and initial
capacity.
ReferenceMap with the
specified reference types, load factor and initial
capacity.
compare method.CursorableLinkedList.Cursor to be notified
of changes to this list.
nCopies copies of the specified object from the Bag.
Map (optional operation).
Map.remove(Object) method.
Map.remove(Object).
Map.remove(Object).
UnsupportedOperationException.
Map.
UnsupportedOperationException.
UnsupportedOperationException.
ListIterator.remove() method.
CollectionMutator is defined for this CompositeSet then this
method will be called anyway.
remove from collection.
remove from collection.
CursorableLinkedList.Listable
from my list.
collection
that are also in retain.
collection
that are also in retain.
List to ensure that no duplicates are present
much like a Set.Set and SortedSet instances.SetUtils should not normally be instantiated.
SingletonIterator is an Iterator over a single
object instance.SingletonIterator where remove
is a permitted operation.
SingletonIterator optionally choosing if
remove is a permitted operation.
SingletonIterator is an ListIterator over a single
object instance.SingletonListIterator.
Map implementation that holds a single item and is fixed size.null to null.
KeyValue.
MapEntry.
Bag that maintains a sorted order among
its unique representative members.java.util.Map that performs well in in a highly
thread-contentious environment.String.valueOf on the input object.Bag to synchronize its behaviour
for a multi-threaded environment.Buffer to synchronize its behaviour
for a multi-threaded environment.Collection to synchronize its behaviour
for a multi-threaded environment.List to synchronize its behaviour
for a multi-threaded environment.Set to synchronize its behaviour for a
multi-threaded environment.SortedBag to synchronize its behaviour
for a multi-threaded environment.SortedSet to synchronize its behaviour
for a multi-threaded environment.1.
UnsupportedOperationException.
LoopingListIterator.next() or
LoopingListIterator.previous().
ListIterator.set(Object) method.
Comparator by which collation occurs.
CompositeCollection.CollectionMutator
or a CompositeSet.SetMutator.
Map.Entry.
Map.size() method.
Map.size().
Map.size().
true iff
I sort true values before
false values.
java.lang.String
representation of the input object.
Collection containing a - b.
Map.Entry tied to a map underneath.TransformIterator that will not function
until the setIterator method is
invoked.
TransformIterator that won't transform
elements from the given iterator.
TransformIterator that will use the
given iterator and transformer.
Bag to transform objects that are added.Buffer to transform objects that are added.Collection to transform objects that are added.List to transform objects that are added.Map to transform objects that are added.Predicate.Set to transform objects that are added.SortedBag to transform objects that are added.SortedMap to transform objects that are added.SortedSet to transform objects that are added.TransformerUtils provides reference implementations and
utilities for the Transformer functor interface.ComparableComparator.
TreeBag.
Bag that maintains order on its unique
representative members according to the given Comparator.
Bag containing all the members of the given
collection.
SortedBag, using a TreeMap to provide
the data storage.TreeBag.
Comparator.
TreeBag containing all the members of the
specified collection.
Comparable interface.List implementation that is optimised for fast insertions and
removals at any index in the list.Bag to validate that elements added
are of a specific type.Buffer to validate that elements added
are of a specific type.Collection to validate that elements added are of a specific type.List to validate that elements
added are of a specific type.Map to validate that elements added
are of a specific type.Set to validate that elements
added are of a specific type.SortedBag to validate that elements added
are of a specific type.SortedMap to validate that elements added
are of a specific type.SortedSet to validate that elements
added are of a specific type.Map.Entry object with key and value from this pair.
String representation of this list, suitable for debugging.
HashMap.
Map.
String.valueOf.
ArrayList instance to be the
list's current size.
Buffer that can grow to any size.UniqueFilterIterator.
Bag to ensure it can't be altered.BidiMap to ensure it can't be altered.UnmodifiableBoundedCollection decorates another
BoundedCollection to ensure it can't be altered.Buffer to ensure it can't be altered.Collection to ensure it can't be altered.Set to ensure it can't be altered.List to ensure it can't be altered.Map to ensure it can't be altered.Map.Entry that throws
UnsupportedOperationException when setValue is called.KeyValue.
Map.Entry.
OrderedBidiMap to ensure it can't be altered.OrderedMap to ensure it can't be altered.Set to ensure it can't be altered.SortedBag to ensure it can't be altered.SortedBidiMap to ensure it can't be altered.SortedMap to ensure it can't be altered.SortedSet to ensure it can't be altered.Collection containing the union
of the given Collections.
Set of unique elements in the Bag.
Iterator.
ListIterator.
MapIterator.
CursorableLinkedList.Cursor from
the set of cursors to be notified of changes to this list.
Map.values() method.
Map.values().
Map.values().
CursorableLinkedList.Cursors currently
open in this list.
|
|||||||||||
| PREV NEXT | FRAMES NO FRAMES | ||||||||||