|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Bag
to provide additional behaviour.Trie
functionality and
utility methods for actual bitwise Trie
implementations.Trie
using the given KeyAnalyzer
.
Collection
to provide additional behaviour.BidiMap
implemented using two maps.createMap
.
createBidiMap
implementation.
IterableGet
that uses a Map
Get
IterableMap
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
.Queue
to provide additional behaviour.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
unless the underlying Iterator
is a ListIterator
.
UnsupportedOperationException
when this method is invoked.
UnsupportedOperationException
.
AbstractMapBag.add(Object)
for each element in the given collection.
Iterable
to the given collection.
Iterator
to the iterators being collated.
value
and inserts it after node
.
value
and inserts it before node
.
Iterator
over any array.ListIterator
over an array.ArrayDeque
instead (available from Java 1.6)ArrayStack
.
ArrayStack
with an initial size.
Iterable
that wraps an iterator.
Runnable
executes.
Bag
and SortedBag
instances.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.
trueFirst
values before
!trueFirst
values.
Map
.Closure
that catches any checked exception and re-throws it as a
FunctorException
runtime exception.Comparator
s, applied
in sequence until one returns not equal or the array is exhausted.
Comparator
s,
applied in (default iterator) sequence until one returns not equal or the
collection is exhausted.
Iterator
s
one after another.
Iterator
s
one after another.
Iterator
s
one after another.
setValue
.
setValue
.
setValue
.
clear()
on all composited Maps.
Map.clear()
behavior with the addition of clearing all
expiration entries as well.
ClosureUtils
provides reference implementations and utilities
for the Closure functor interface.Iterator
s.
Iterator
s.
Iterator
s.
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.EditScript
objects.Comparator
that compares Comparable
objects.Comparator
objects.null
Boolean
objects
according to the value of BooleanComparator.sortsTrueFirst()
.
Comparable
arguments.
Bag
to comply with the Collection contract.set
composited.
true
if the bag contains all elements in
the given collection, respecting cardinality.
true
iff all elements of coll2
are also contained
in coll1
.
true
iff at least one element is in both collections.
AbstractHashedMap
to convert keys to
lower case.
Set
with the same type as the provided set
and populate it with all elements of list
.
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.Map
returning a default value if the map
does not contain the requested key.DefaultedMap
that decorates
a HashMap
.
DefaultedMap
that decorates a HashMap
.
Equator
implementation.null
,
the value of defaultList
.
KeyValue
pair that does not implement
Map.Entry
.KeyValue
.
Map.Entry
.
Map.Entry
that prevents
the Map.Entry
contract from being broken.KeyValue
.
Map.Entry
.
Collection
containing the exclusive disjunction
(symmetric difference) of the given Iterable
s.
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 LinkedHashMap
instances.HashBidiMap
.
LinkedHashBidiMap
and copies the mappings from
specified Map
.
LinkedHashBidiMap
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.
commands
needed to transform
one objects sequence into another objects sequence.true
if this stack is currently empty.
Bag
.
null
,
or the argument itself otherwise.
null
,
or the argument itself otherwise.
null
,
or the argument itself otherwise.
null
,
or the argument itself otherwise.
Queue
.
SortedBag
.
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.KeyAnalyzer.bitIndex(Object, int, int, Object, int, int)
if key and found key are equal.
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.
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
.
Object.equals(Object)
.
count
times.
FactoryUtils
provides reference implementations and utilities
for the Factory functor interface.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.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 Iterator
, throwing
IndexOutOfBoundsException
if there is no such element.
index
-th value in the iterable
's Iterator
, throwing
IndexOutOfBoundsException
if there is no such element.
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.
index
-th Map.Entry
in the map
's entrySet
,
throwing IndexOutOfBoundsException
if there is no such element.
Map
interface.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()
.
next()
.
next()
.
next()
.
KeyAnalyzer
that constructed the Trie
.
EditScript
object.
true
values before false
values.
next()
.
next()
.
next()
.
next()
.
next()
.
List
to make it seamlessly grow when
indices larger than the list size are used on add and set,
avoiding most IndexOutOfBoundsExceptions.Bag
, using a HashMap
to provide the
data storage.HashBag
.
equals
.
equals
.
equals
.
equals
.
NullComparator.equals(Object)
.
equals
.
equals
.
null
objects.
List.hashCode()
.
Set.hashCode()
.
Map
implementation that is a general purpose alternative
to HashMap
.true
if any child iterator has remaining elements.
IndexedCollection
.
readObject
.
readObject
.
StringKeyAnalyzer
.
Collection
containing the intersection of the given
Iterable
s.
Collection
s contain
exactly the same elements with exactly the same cardinalities.
Collection
s contain
exactly the same elements with exactly the same cardinalities.
List.equals(java.lang.Object)
.
equals()
contract
in Set.equals(java.lang.Object)
.
Map
interface.Map
as an IterableMap
.
SortedMap
+ OrderedMap
.SortedMap
as an IterableSortedMap
.
Iterator
over the entire set of members,
including copies due to cardinality.
MultiValueMap
.
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
instance appear to be an
Iterable
instance.IteratorIterable
that will use the given
iterator.
IteratorIterable
that will use the given
iterator.
Iterator
instances.Trie
keys on a bit level.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.Character
.
Map
implementation that maintains the order of the entries.Iterator
into a ResettableListIterator
.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.CharSequence
objects.
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.
MapIterator
over the map.
A map iterator is an efficient way of iterating over maps. There is no need to access the entry set or use Map Entry objects.
IterableMapmap = new HashedMap (); MapIterator it = map.mapIterator(); while (it.hasNext()) { String key = it.next(); Integer value = it.getValue(); it.setValue(value + 1); }
MapIterator
over the map.
Map
.OrderedMapIterator
over the map.
Map
and SortedMap
instances.MultiKey
allows multiple map keys to be merged together.Map
implementation that uses multiple keys to map the value.HashedMap
.
MultiKeyMap.multiKeyMap(AbstractHashedMap)
.
HashMap
and
storing the multiple values in an ArrayList
.
map
and
creates the value collections using the supplied collectionFactory
.
map
and
maps keys to collections of type collectionClass
.
map
and
creates the value collections using the supplied collectionFactory
.
Map
.
Map
.
Map
.
AbstractLinkedList.LinkedListIterator.next()
.
Map
.
Map
.
LoopingListIterator.next()
.
AbstractLinkedList.LinkedListIterator.next
.
List
implementation that stores a cache of internal Node objects
in an effort to reduce wasteful object creation.Iterator
over a NodeList
.org.w3c.NodeList
Iterator
that wraps the specified NodeList
.
Iterator
that wraps the specified node's childNodes.
IndexedCollection
for a non-unique index.
KeyAnalyzer.bitIndex(Object, int, int, Object, int, int)
if key's bits are all 0.
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.
Iterator
over an array of objects.ListIterator
over an array of objects.Map
.Bag
and
SortedBag
interfaces.BidiMap
,
OrderedBidiMap
and
SortedBidiMap
interfaces.Collection
interface.Comparator
interface.Closure
,
Predicate
,
Transformer
and
Factory
interfaces.Iterator
interface.List
interface.Map
,
IterableMap
,
OrderedMap
and
SortedMap
interfaces.Queue
interface.Set
and
SortedSet
interfaces.Put
and
Get
interfaces,
with differing generic types.Trie
interface.KeyAnalyzer
implementations.sublists
of a
list, each of the same size (the final list may be smaller).
Map
to evict expired entries once their expiration
time has been reached.PassiveExpiringMap.ConstantTimeToLiveExpirationPolicy
expiration policy.
PassiveExpiringMap.ConstantTimeToLiveExpirationPolicy
expiration policy.
PassiveExpiringMap.ConstantTimeToLiveExpirationPolicy
expiration policy.
PassiveExpiringMap.ConstantTimeToLiveExpirationPolicy
expiration policy.
ExpirationPolicy
that returns a expiration time that is a
constant about of time in the future from the current time.Collection
of all the permutations of the input collection.
Transformer
to transform the elements
into keys, using the unaltered element as the value in the Map
.
Transformer
s to transform the elements
into keys and values.
Transformer
to transform the elements
into keys, using the unaltered element as the value in the MultiMap
.
Transformer
s to transform the elements
into keys and values.
Bag
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.Queue
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.Trie
of all elements that are prefixed
by the given key.
Map
.
ArrayListIterator.previous()
is called.
LoopingListIterator.previous()
.
ObjectArrayListIterator.previous()
is called.
Map
interface.Queue
instances.Get
as an instance of IterableMap
.
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.
Collection
.
nCopies
copies of the specified object from the Bag.
Map
(optional operation).
Map
(optional operation).
UnsupportedOperationException
.
Map
.
UnsupportedOperationException
if ListIteratorWrapper.previous()
has ever been called.
UnsupportedOperationException
.
UnsupportedOperationException
.
UnsupportedOperationException
.
Map
(optional operation).
Map.remove(Object)
behavior with the addition of removing
any expiration entry as well.
Map
(optional operation).
CollectionMutator
is defined for this CompositeSet then this
method will be called anyway.
remove
from collection
.
remove
from collection
.
collection
that are also in retain
.
collection
that are also in retain
.
compare
method.1
.
UnsupportedOperationException
unless the underlying Iterator
is a ListIterator
.
LoopingListIterator.next()
or
LoopingListIterator.previous()
.
Comparator
by which collation occurs.
List
to ensure that no duplicates are present much
like a Set
.Set
and SortedSet
instances.Map.Entry
.
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.
Put
and/or Get
but not Map
.java.util.Map
that performs well in in a highly
thread-contentious environment.KeyAnalyzer
for String
s.String.valueOf
on the input object.java.lang.String
representation of the input object.
Collection
containing a - b.
Collection
containing a minus a subset of
b.
Bag
to synchronize its behaviour
for a multi-threaded environment.Collection
to synchronize its behaviour
for a multi-threaded environment.SortedBag
to synchronize its behaviour
for a multi-threaded environment.Map.Entry
tied to a map underneath.Map.Entry
object with key and value from this pair.
Map
.
String.valueOf
.
Bag
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
.Queue
to transform objects that are added.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.Map
to transform objects that are added.TransformerUtils
provides reference implementations and
utilities for the Transformer functor interface.ComparableComparator
.
TransformIterator
that will not function
until the setIterator
and
TransformIterator.setTransformer(Transformer)
methods are 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.Trie
utilities.Collection
containing the union of the given
Iterable
s.
UniqueFilterIterator
.
IndexedCollection
for a unique index.
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.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.KeyValue
.
Map.Entry
.
MapIterator
.
OrderedBidiMap
to ensure it can't be altered.OrderedMap
to ensure it can't be altered.Queue
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.Trie
.Trie
Put
as an instanceof Map
.
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |