|
||||||
| PREV NEXT | FRAMES NO FRAMES | |||||
i copies of the given object to the bag and
keep a count.
UnsupportedOperationException.
ListIterator.add(Object) method.
UnsupportedOperationException.
Collection's Iterator.
DefaultMapBag.add(Object) for each element in the given collection.
Iterator to my collection to collate.
Iterator over an array of objects.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.
Collection that counts the number of times an object appears in
the collection.Bag
and SortedBag instances.BeanMap.
BeanMap that operates on the
specified bean.
BeanMap.MyMapEntry.
PriorityQueue and Buffer.BinaryHeap that will use the given
comparator to order its elements.
BinaryHeap.
BinaryHeap.
BinaryHeap.
Buffer.get() and Buffer.remove() operations.
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 objects.Comparators.
Comparators.
Comparators.
Iterators
one after another.
Iterators
one after another.
Iterators
one after another.
Map.clear() method.
Map.clear().
Map.clear().
FastArrayList instance.
FastHashMap instance.
FastTreeMap instance.
Iterators.
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 related utility methods.CollectionUtils.
null
if this map uses its keys' natural order.
Comparator
objects.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 some element of a
is also an element of b (or, equivalently, if
some element of b is also an element of a).
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).
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 preceeding it (if any).
List interface,
supporting a ListIterator that allows concurrent modifications
to the underlying list.Bag
interface to minimize the effort required for target implementations.Map.EntryDefaultMapEntry with a null key
and null value.
DefaultMapEntry with the given
key and given value.
Collection containing the exclusive disjunction
(symmetric difference) of the given Collections.
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() method.
Map.entrySet().
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.
Map.Entry.equals(Object)
Map.equals(Object) method.
Map.equals(Object).
Map.equals(Object).
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 which takes a Predicate instance to filter
out objects from an underlying Iterator instance.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.
BeanMap.put(Object,Object) operation.
Map.get(Object) method.
Map.get(Object).
Map.get(Object).
Boolean.
Byte.
Map mapping each unique element in
the given Collection to an Integer
representing the number of occurances of that element
in the Collection.
Comparator by which I collate.
Double.
Float.
Integer.
CursorableLinkedList.Listable
at the specified index.
Long.
Number.
Map.get(Object).
Short.
Bag that is backed by a HashMap.HashBag.
Bag containing all the members of the given
collection.
NullComparator.equals(Object).
Map.Entry.hashCode()
Map.hashCode() method.
Map.hashCode().
Map.hashCode().
true if any child iterator has remaining elements.
ListIterator.hasNext() method.
ListIterator.hasPrevious() method.
equals() method, and return
the corresponding index, or -1 if the object is not found.
Collection containing the intersection
of the given Collections.
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 cardinality.
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 instancesIteratorEnumeration that will not
function until setIterator is
invoked.
IteratorEnumeration that will use
the given iterator.
Iterator
instances.Map.keySet() method.
Map.keySet().
Map.keySet().
equals() method, and return
the corresponding index, or -1 if the object is not found.
ListIteratorWrapper that will wrap
the given iterator.
List
instances.ListUtils.
System.out.
System.out.
System.err.
Map used for default implementations.
Map instances.MapUtils.
MultiHashMap is the default implementation of the
MultiMap interface.ListIterator.next() method.
ListIterator.nextIndex() method.
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.
null values.
null values.
Comparator implementations.Iterator implementations and utilities.ListIterator.previous() method.
ListIterator.previousIndex() method.
Iterator which delegates its methods to a proxy instance.ProxyIterator that will not function
until ProxyIterator.setIterator(Iterator) is called.
ProxyIterator that will use the
given iterator.
ListIterator which delegates its
methods to a proxy instance.ProxyListIterator that will not
function until setListIterator
is invoked.
ProxyListIterator that will use the
given list iterator.
Map wraps another Map
implementation, using the wrapped instance for its default
implementation.Map.
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.ReferenceMap that will
use hard references to keys and soft references to values.
ReferenceMap that will
use the specified types of references.
ReferenceMap with the
specified reference types, load factor and initial
capacity.
CursorableLinkedList.Cursor to be notified
of changes to this list.
Bag.uniqueSet().
UnsupportedOperationException.
Collection is known.
UnsupportedOperationException.
ListIterator.remove() method.
UnsupportedOperationException.
UnsupportedOperationException.
Map.remove(Object) method.
Map.remove(Object).
Map.remove(Object).
CursorableLinkedList.Listable
from my list.
1.
UnsupportedOperationException.
ListIterator.set(Object) method.
Comparator by which I collate.
Set
and SortedSet instances.SingletonIterator is an Iterator over a single
object instance.SingletonIterator.
SingletonIterator is an ListIterator over a single
object instance.SingletonListIterator.
Map.size() method.
Map.size().
Map.size().
Bag that maintains order among its unique
representative members.java.util.Map that performs well in in a highly
thread-contentious environment.Collection containing a - b.
String representation of this list, suitable for debugging.
Iterator which uses a Transformer instance to
transform the contents of the Iterator into some other formTransformIterator 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 that is backed by a TreeMap.TreeBag.
Bag that maintains order on its unique
representative members according to the given Comparator.
Bag containing all the members of the given
collection.
ArrayList instance to be the
list's current size.
Collection containing the union
of the given Collections.
UniqueFilterIterator.
Set of unique members that represent all members in
the bag.
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 | |||||