Interface | Description |
---|---|
Bag |
A
Collection that counts the number of times an object appears in
the collection. |
Buffer |
A Buffer is a collection that allows objects to be removed in some
well-defined order.
|
Closure |
An interface to represent some Closure, a block of code which is executed
from inside some block, function or iteration which operates on an input
object.
|
Factory |
Factory
A simple interface that describes the most basic means of having the ability
to create an object.
|
MultiMap |
This is simply a Map with slightly different semantics.
|
Predicate |
Performs some predicate which returns true or false based on the input object.
|
PriorityQueue |
Interface for priority queues.
|
SortedBag |
A type of
Bag that maintains order among its unique
representative members. |
Transformer |
An object capable of transforming an input object into some output object.
|
Class | Description |
---|---|
ArrayStack |
An implementation of the
Stack API that is based on an
ArrayList instead of a Vector , so it is not
synchronized to protect against multi-threaded access. |
BagUtils | |
BeanMap |
An implementation of Map for JavaBeans which uses introspection to
get and put properties in the bean.
|
BeanMap.MyMapEntry |
Map entry used by
BeanMap . |
BinaryHeap |
Binary heap implementation of
PriorityQueue and Buffer . |
BoundedFifoBuffer |
The BoundedFifoBuffer is a very efficient implementation of
Buffer that does not alter the size of the buffer at runtime.
|
BufferUtils |
Contains static utility methods for operating on
Buffer objects. |
CollectionUtils |
A set of
Collection related utility methods. |
ComparatorUtils |
Provides convenient static utility methods for
Comparator
objects. |
CursorableLinkedList |
A doubly-linked list implementation of the
List interface,
supporting a ListIterator that allows concurrent modifications
to the underlying list. |
DefaultMapBag |
This class provides a skeletal implementation of the
Bag
interface to minimize the effort required for target implementations. |
DefaultMapEntry |
A default implementation of
Map.Entry |
DoubleOrderedMap |
Red-Black tree-based implementation of Map.
|
ExtendedProperties |
This class extends normal Java properties by adding the possibility
to use the same key many times concatenating the value strings
instead of overwriting them.
|
FastArrayList |
A customized implementation of
java.util.ArrayList designed
to operate in a multithreaded environment where the large majority of
method calls are read-only, instead of structural changes. |
FastHashMap |
A customized implementation of
java.util.HashMap designed
to operate in a multithreaded environment where the large majority of
method calls are read-only, instead of structural changes. |
FastTreeMap |
A customized implementation of
java.util.TreeMap designed
to operate in a multithreaded environment where the large majority of
method calls are read-only, instead of structural changes. |
HashBag |
An implementation of
Bag that is backed by a HashMap . |
IteratorUtils |
Provides static utility methods and decorators for
Iterator
instances. |
ListUtils |
Contains static utility methods and decorators for
List
instances. |
LRUMap |
An implementation of a Map which has a maximum size and uses a Least Recently Used
algorithm to remove items from the Map when the maximum size is reached and new items are added.
|
MapUtils |
A helper class for using
Map instances. |
MultiHashMap |
MultiHashMap is the default implementation of the
MultiMap interface. |
ProxyMap |
This
Map wraps another Map
implementation, using the wrapped instance for its default
implementation. |
ReferenceMap |
Hashtable-based
Map implementation that allows
mappings to be removed by the garbage collector. |
SequencedHashMap |
A map of objects whose mapping entries are sequenced based on the order in
which they were added.
|
SetUtils |
Provides static utility methods and decorators for
Set
and SortedSet instances. |
StaticBucketMap |
A StaticBucketMap is an efficient, thread-safe implementation of
java.util.Map that performs well in in a highly
thread-contentious environment. |
SynchronizedPriorityQueue |
A thread safe version of the PriorityQueue.
|
TreeBag |
An implementation of
Bag that is backed by a TreeMap . |
UnboundedFifoBuffer |
UnboundedFifoBuffer is a very efficient buffer implementation.
|
Exception | Description |
---|---|
BufferOverflowException |
The BufferOverflowException is used when the buffer's capacity has been
exceeded.
|
BufferUnderflowException |
The BufferUnderflowException is used when the buffer is already empty
|
Java Collections Framework extensions.
See also the java.util package.
Category | Classes | Comments |
---|---|---|
List Implementations |
CursorableLinkedList FastArrayList
|
Special-purpose implementations of the List interface.
|
Map Implementations |
BeanMap DoubleOrderedMap ExtendedProperties FastHashMap FastTreeMap LRUMap MultiHashMap ProxyMap ReferenceMap SequencedHashMap SoftRefHashMap StaticBucketMap |
Special-purpose implementations of the Map interface and associated classes.
|
Buffer Interface and Implementations |
ArrayStack BinaryHeap BoundedFifoBuffer Buffer PriorityQueue SynchronizedPriorityQueue
UnboundedFifoBuffer
|
New collection interface that specifies a removal order for the collection, used to implement queues and queue-like things. | Bag Interface and Implementations |
Bag DefaultMapBag HashBag SortedBag TreeBag
|
New collections interface that keeps a count of its members. |
Utilities |
BagUtils BufferUtils CollectionUtils ComparatorUtils ListUtils MapUtils SetUtils
|
Manipulate collection objects, determine set theoretic properties, ensure type-safety, provide decorators, etc. |
Functor Interfaces |
Factory Predicate Closure Transformer |
Create views or functors on a collection. If your collection represents X, these allow you to define and look at f(X). |
Miscellaneous |
StringStack DefaultMapEntry |
A stack of strings; and the trivial implementation of
Map.Entry .
|
Copyright © 2001-2004 Apache Software Foundation. Documenation generated March 13 2014.