org.apache.commons.collections

This package contains the interfaces and utilities shared across all the subpackages of this component.

The following collection implementations are provided in the package:

• ArrayStack - a non synchronized Stack that follows the same API as java util Stack
• ExtendedProperties - extends the Properties class to add extra functionality

To use, simply extend this class, and implement the AbstractTestObject.makeObject() method.

If your Object fails one of these tests by design, you may still use this base set of cases.

This extended Map represents a mapping where a key may lookup a value and a value may lookup a key with equal ease. This interface extends Map and so may be used anywhere a map is required.

The PriorityQueue interface has now been replaced for most uses by the Buffer interface.

The size of the collection can vary, but it can never exceed a preset maximum number of elements.

The removal order of a BoundedFifoBuffer is based on the insertion order; elements are removed in the same order in which they were added.

The size of the map can vary, but it can never exceed a preset maximum number of elements.

The removal order can be based on insertion order (eg, a FIFO queue or a LIFO stack), on access order (eg, an LRU cache), on some arbitrary comparator (eg, a priority queue) or on any other well-defined ordering.

Note that the removal order is not necessarily the same as the iteration order.

A simple test method is the type of test traditionally supplied by by TestCase .

A Closure represents a block of code which is executed from inside some block, function or iteration.

Most of the functionality in this class can also be found in the comparators package.

The map will be used to map bag elements to a number; the number represents the number of occurrences of that element in the bag.
since:
   Commons Collections 2.0
version:
   $Revision: 357494 $ $Date: 2005-12-18 19:05:31 +0000 (Sun, 18 Dec 2005) $
author:
   Chuck Burdick
author:
   Michael A.

Please consider using the PropertiesConfiguration class in Commons-Configuration as soon as it is released.

The Extended Properties syntax is explained here:

• Each property has the syntax key = value
• The key may use any character but the equal sign '='.
• value may be separated on different lines if a backslash is placed at the end of the line that continues below.
• If value is a list of strings, each token is separated by a comma ','.
• Commas in each token are escaped placing a backslash right before the comma.
• Backslashes are escaped by using two consecutive backslashes i.e.

A Factory creates an object without using an input parameter. If an input parameter is required, then Transformer is more appropriate.

Standard implementations of common factories are provided by FactoryUtils .

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.

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.

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.

A Map Entry has considerable additional semantics over and above a simple key-value pair.

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.

A synchronized version can be obtained with: Collections.synchronizedMap( theMapToSynchronize ) If it will be accessed by multiple threads, you _must_ synchronize access to this Map.

This iterator is a special version designed for maps.

A Predicate is the object equivalent of an if statement. It uses the input object to return a true or false value, and is often used in validation or filtering.

Standard implementations of common predicates are provided by PredicateUtils .

This Map wraps another Map implementation, using the wrapped instance for its default implementation.

When you construct a ReferenceMap, you can specify what kind of references are used to store the map's keys and values.

Test cases for DoubleOrderedMap.

To use, simply extend this class, and implement the TestLinkedList.makeLinkedList method.

If your LinkedList fails one of these tests by design, you may still use this base set of cases.

A Transformer converts the input object to the output object. The input object should be left unchanged. Transformers are typically used for type conversions, or extracting data from an object.

Standard implementations of common transformers are provided by TransformerUtils .

The removal order of an UnboundedFifoBuffer is based on the insertion order; elements are removed in the same order in which they were added. The iteration order is the same as the removal order.

The UnboundedFifoBuffer.remove() and UnboundedFifoBuffer.get() operations perform in constant time. The UnboundedFifoBuffer.add(Object) operation performs in amortized constant time.

This interface enables testing such as:

 if (coll instanceof Unmodifiable) {
 coll = new ArrayList(coll);
 }
 // now we know coll is modifiable