| Interface | Description |
|---|---|
| ConcurrentNavigableMap<K,V> |
A
ConcurrentMap supporting NavigableMap operations. |
| ConcurrentReferenceHashMap.KeyReference | |
| NavigableMap<K,V> |
A
SortedMap extended with navigation methods returning the
closest matches for given search targets. |
| Queue<E> |
An iterface used to implement a first-in, first-out container.
|
| SecurityActions.GetClassLoaderAction | |
| ValueRef<K,V> |
ValueRef.
|
| Class | Description |
|---|---|
| AbstractQueue<E> |
An abstract implementation of a Queue.
|
| ArrayIterator |
An array iterator.
|
| CachedCollection |
A wrapper around a
Collection which translates added objects
into SoftObject references, allowing the VM to garbage collect
objects in the collection when memory is low. |
| CachedList |
A wrapper around a
List which translates added objects
into SoftObject references, allowing the VM to garbage collect
objects in the collection when memory is low. |
| CollectionsFactory |
Collections factory.
|
| CollectionsUtil |
CollectionsUtil.
|
| CompoundIterator |
A compound iterator, which iterates over all of the elements in the
given iterators.
|
| CompoundKey |
An immutable compound key class.
|
| ConcurrentReferenceHashMap<K,V> |
An advanced hash table supporting configurable garbage collection semantics
of keys and values, optional referential-equality, full concurrency of
retrievals, and adjustable expected concurrency for updates.
|
| ConcurrentReferenceHashMap.HashEntry<K,V> |
ConcurrentReferenceHashMap list entry.
|
| ConcurrentReferenceHashMap.Segment<K,V> |
Segments are specialized versions of hash tables.
|
| ConcurrentReferenceHashMap.SimpleEntry<K,V> | |
| ConcurrentReferenceHashMap.SoftKeyReference<K> |
A soft-key reference which stores the key hash needed for reclamation.
|
| ConcurrentReferenceHashMap.SoftValueReference<V> | |
| ConcurrentReferenceHashMap.WeakKeyReference<K> |
A weak-key reference which stores the key hash needed for reclamation.
|
| ConcurrentReferenceHashMap.WeakValueReference<V> | |
| ConcurrentReferenceHashSet<E> |
Set based on top of ConcurrentReferenceHashMap.
|
| ConcurrentSet<E> |
Concurrent Set based on top of ConcurrentHashMap.
|
| ConcurrentSkipListMap<K,V> |
A scalable
ConcurrentNavigableMap implementation. |
| ConcurrentSkipListMap.ComparableUsingComparator<K> |
Represents a key with a comparator as a Comparable.
|
| ConcurrentSkipListMap.ConcurrentSkipListSubMap<K,V> |
Submaps returned by
ConcurrentSkipListMap submap operations
represent a subrange of mappings of their underlying
maps. |
| ConcurrentSkipListMap.HeadIndex<K,V> |
Nodes heading each level keep track of their level.
|
| ConcurrentSkipListMap.Index<K,V> |
Index nodes represent the levels of the skip list.
|
| ConcurrentSkipListMap.Node<K,V> |
Nodes hold keys and values, and are singly linked in sorted
order, possibly with some intervening marker nodes.
|
| ConcurrentSkipListMap.SnapshotEntry<K,V> |
An immutable representation of a key-value mapping as it
existed at some point in time.
|
| FastCopyHashMap<K,V> |
A HashMap that is optimized for fast shallow copies.
|
| FastCopyHashMap.Entry<K,V> | |
| FastCopyHashMap.SimpleEntry<K,V> | |
| FastCopyHashSet<E> |
Concurrent Set based on top of FastCopyHashMap.
|
| Iterators |
A collection of
Iterator and Enumeration
utilities. |
| Iterators.EmptyIterator |
An empty Iterator
|
| Iterators.Enum2Iterator |
An Enumeration to Iterator wrapper.
|
| Iterators.ImmutableIterator |
Wraps an Iterator making it immutable, by disabling calls to
remove() |
| Iterators.Iter2Enumeration |
An Iterator to Enumeration wrapper class.
|
| Iterators.SyncEnumeration |
Wraps an Enumeration making it synchronized.
|
| Iterators.SyncIterator |
Wraps an Iterator making it synchronized.
|
| LazyList<T> |
LazyList.
|
| LazyMap<K,V> |
LazyMap.
|
| LazySet<T> |
LazySet.
|
| ListQueue<E> |
A ListQueue implements a first-in, first-out container using a List as
a data structure.
|
| ListSet |
A thin wrapper around a
List transforming it into a
modifiable Set. |
| MapDelegateSet<E> |
Set implemented by a backing Map.
|
| ReferenceValueHashMap<K,V> |
This Map will remove entries when the value in the map has been
cleaned from garbage collection
|
| ReferenceValueMap<K,V> |
This Map will remove entries when the value in the map has been
cleaned from garbage collection
|
| ReferenceValueTreeMap<K,V> |
This Map will remove entries when the value in the map has been
cleaned from garbage collection
|
| ReverseListIterator<E> |
An iterator that returns elements in reverse order from a list.
|
| SecurityActions | |
| SerializableEnumeration |
???
|
| SoftSet |
An implementation of Set that manages a map of soft references to
the set values.
|
| SoftSet.ComparableSoftReference | |
| SoftSet.ComparableSoftReferenceIterator | |
| SoftValueHashMap<K,V> |
This Map will remove entries when the value in the map has been
cleaned from garbage collection
|
| SoftValueRef<K,V> |
Soft value ref.
|
| SoftValueTreeMap<K,V> |
This Map will remove entries when the value in the map has been
cleaned from garbage collection
|
| WeakClassCache<T> |
A weak class cache that instantiates does not a hold a
strong reference to either the classloader or class.
|
| WeakIdentityHashMap |
A hashtable-based Map implementation with weak keys and
using reference-equality in place of object-equality when comparing keys
(and values).
|
| WeakIdentityHashMap.Entry |
The entries in this hash table extend WeakReference, using its main ref
field as the key.
|
| WeakIdentityHashMap.SimpleEntry | |
| WeakSet |
A Set implementation with weak elements.
|
| WeakTypeCache<T> |
A weak class cache that instantiates does not a hold a
strong reference to either the classloader or class.
|
| WeakValueHashMap<K,V> |
This Map will remove entries when the value in the map has been
cleaned from garbage collection
|
| WeakValueRef<K,V> |
Weak value ref.
|
| WeakValueTreeMap<K,V> |
This Map will remove entries when the value in the map has been
cleaned from garbage collection
|
| Enum | Description |
|---|---|
| ConcurrentReferenceHashMap.Option | |
| ConcurrentReferenceHashMap.ReferenceType |
An option specifying which Java reference type should be used to refer
to a key and/or value.
|
| Exception | Description |
|---|---|
| CollectionException |
A generic collection exception.
|
| EmptyCollectionException |
Thrown to indicate that an operation can not be performed on an empty
collection.
|
| FullCollectionException |
Thrown to indicate that an operation can not be performed on a full
collection.
|
Extentions to the Java Collections framework.