|
||||||||||
| 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.createBidiMap implementation.
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.nCopies copies of the specified object to the Bag.
UnsupportedOperationException when this method is invoked.
UnsupportedOperationException.
UnsupportedOperationException when this method is invoked.
UnsupportedOperationException.
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.
TransformedList.add(int, Object) (but breaks List interface).
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.
Bag and SortedBag instances.BeanMap.
BeanMap that operates on the
specified bean.
BeanMap.MyMapEntry.
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
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.
Map.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.
clear() on all composited Maps.
FastArrayList instance.
FastHashMap instance.
FastTreeMap 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 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.null
if this map uses its keys' natural order.
Comparator
objects.null Boolean objects
according to the value of BooleanComparator.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 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.
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.
AbstractLinkedList.LinkedListIterator.next() or AbstractLinkedList.LinkedListIterator.previous().
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.
List implementation with a ListIterator that
allows concurrent modifications to the underlying list.ListIterator that allows concurrent changes to
the underlying list.NodeCachingLinkedList.maximumCacheSize.
Map.Entry that prevents
the MapEntry contract from being broken.Collection containing the exclusive disjunction
(symmetric difference) of the given Collections.
put() to work in the superclass.
put() to work in deserialization.
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 Comparators.
DualTreeBidiMap that decorates the specified maps.
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.
MapIterator using a Map entrySet.value field from a HashEntry.
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 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
setPredicate is invoked.
FilterListIterator that will not
function until setPredicate is invoked.
FilterListIterator.
FilterListIterator.
AbstractMap.put(Object,Object) operation.
null if no nodes are cached.
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
nested Throwable root cause.
FunctorException with specified
detail message and nested Throwable root cause.
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.
equals.
equals.
equals.
NullComparator.equals(Object).
equals.
List.hashCode().
Set.hashCode().
Map implementation that is a general purpose alternative
to HashMap.true if any child iterator has remaining elements.
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().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.
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 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.equals() method, and return
the corresponding index, or -1 if the object is not found.
next()
or previous().
next()
or previous().
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.
System.out.
System.out.
System.err.
Map implementation with a fixed maximum size which removes
the least recently used entry if an entry is added when full.Map to obtain Set behaviour.MapIterator over the map.
MapIterator over the map.
MapIterator over the map.
Map.Map and SortedMap instances.MapUtils should not normally be instantiated.
MultiHashMap is the default implementation of the
MultiMap interface.MultiKey allows multiple map keys to be merged together.Map implementation that uses multiple keys to map the value.HashedMap.
MultiKeyMap.decorate(AbstractHashedMap).
Map.
AbstractLinkedList.LinkedListIterator.next().
Map.
AbstractLinkedList.LinkedListIterator.next.
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 or lower than
any non-null object it is compared with.
null values.
null values.
Iterator over an array of objects.setArray.
ListIterator over an array of objects.setArray.
OrderedMapIterator over the map.
OrderedMapIterator over the map.
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.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.PredicateUtils provides reference implementations and utilities
for the Predicate functor interface.Map.
ArrayListIterator.previous() is called.
ObjectArrayListIterator.previous() is called.
Buffer that provides for
removal based on Comparator ordering.MultiKeyMap.putMultiKey(V, K...)
MultiKeyMap.putMultiKey(V, K...)
MultiKeyMap.putMultiKey(V, K...)
MultiKeyMap.putMultiKey(V, K...)
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.
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.
nCopies copies of the specified object from the Bag.
UnsupportedOperationException.
Map.
UnsupportedOperationException.
UnsupportedOperationException.
Map (optional operation).
CollectionMutator is defined for this CompositeSet then this
method will be called anyway.
compare method.1.
UnsupportedOperationException.
Comparator by which collation occurs.
CompositeCollection.CollectionMutator
or a CompositeSet.SetMutator.
TransformedList.set(int, Object) (but breaks List interface).
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.true iff
I sort true values before
false values.
java.util.Map that performs well in in a highly
thread-contentious environment.String.valueOf.java.lang.String
representation of the input object.
Collection containing a - b.
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.Map.Entry object with key and value from this pair.
Map.
String.valueOf.
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.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.
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.ArrayList instance to be the
list's current size.
Buffer 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.SortedSet to validate that elements
added are of a specific type.Collection containing the union
of the given Collections.
UniqueFilterIterator.
Set of unique elements in the Bag.
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.Iterator.
List to ensure it can't be altered.ListIterator.
Map to ensure it can't be altered.Map.Entry that throws UnsupportedOperationException
when setValue is called.MapIterator.
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.
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||