Package org.apache.commons.collections

Java Collections Framework extensions.

Interface Summary

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.
ClosureAn 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.
PredicatePerforms 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.
TransformerAn object capable of transforming an input object into some output object.

Class Summary

ArrayEnumeration Enumeration wrapper for array.
ArrayIteratorImplements an java.util.Iterator over an array of objects.
ArrayStack An implementation of the java.util.Stack API that is based on an ArrayList instead of a Vector, so it is not synchronized to protect against multi-threaded access.
BagUtils Provides utility methods and decorators for Bag and SortedBag instances.
BeanMapAn 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.
BufferOverflowException The BufferOverflowException is used when the buffer's capacity has been exceeded.
BufferUnderflowException The BufferUnderflowException is used when the buffer is already empty
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.
CursorableLinkedList.Cursor
DefaultMapBag This class provides a skeletal implementation of the Bag interface to minimize the effort required for target implementations.
DefaultMapEntryA default implementation of java.util.Map.Entry
DoubleOrderedMap Red-Black tree-based implementation of Map.
EnumerationIteratorAdapter to make Enumeration instances appear to be Iterator instances.
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.
FilterIteratorA Proxy Iterator which takes a Predicate instance to filter out objects from an underlying Iterator instance.
FilterListIterator A proxy ListIterator which takes a Predicate instance to filter out objects from an underlying ListIterator instance.
HashBag An implementation of Bag that is backed by a HashMap.
IteratorEnumerationAdapter to make an Iterator instance appear to be an Enumeration instances
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.
ProxyIteratorA Proxy Iterator which delegates its methods to a proxy instance.
ProxyListIterator A proxy ListIterator which delegates its methods to a proxy instance.
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.
SingletonIteratorSingletonIterator is an Iterator over a single object instance.
SoftRefHashMap HashMap with SoftReference links to values which allows the values of the Map to be garbage collected by the JVM if it becomes low on memory.
StaticBucketMap A StaticBucketMap is an efficient, thread-safe implementation of java.util.Map that performs well in in a highly thread-contentious environment.
StringStack This class implements a stack for String objects.
SynchronizedPriorityQueue A thread safe version of the PriorityQueue.
TransformIteratorA Proxy Iterator which uses a Transformer instance to transform the contents of the Iterator into some other form
TreeBag An implementation of Bag that is backed by a TreeMap.
UnboundedFifoBuffer UnboundedFifoBuffer is a very efficient buffer implementation.
Java Collections Framework extensions.

See also the java.util package.

CategoryClassesComments
List Implementations CursorableLinkedList
FastArrayList
Special-purpose implementations of the java.util.List interface.
Map Implementations BeanMap
DoubleOrderedMap
ExtendedProperties
FastHashMap
FastTreeMap
LRUMap
MultiHashMap
ProxyMap
ReferenceMap
SequencedHashMap
SoftRefHashMap
StaticBucketMap
Special-purpose implementations of the java.util.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 java.util.Map.Entry.

Copyright © 2001-2004 Apache Software Foundation. Documenation generated ${TODAY}.