org.apache.commons.collections.map

Interface Summary
Interface	Description
CompositeMap.MapMutator	This interface allows definition for all of the indeterminate mutators in a CompositeMap, as well as providing a hook for callbacks on key collisions.

Class Summary
Class	Description
AbstractHashedMap	An abstract implementation of a hash-based map which provides numerous points for subclasses to override.
AbstractHashedMap.EntrySet	EntrySet implementation.
AbstractHashedMap.EntrySetIterator	EntrySet iterator.
AbstractHashedMap.HashEntry	HashEntry used to store the data.
AbstractHashedMap.HashIterator	Base Iterator
AbstractHashedMap.HashMapIterator	MapIterator implementation.
AbstractHashedMap.KeySet	KeySet implementation.
AbstractHashedMap.KeySetIterator	KeySet iterator.
AbstractHashedMap.Values	Values implementation.
AbstractHashedMap.ValuesIterator	Values iterator.
AbstractInputCheckedMapDecorator	An abstract base class that simplifies the task of creating map decorators.
AbstractInputCheckedMapDecorator.EntrySet	Implementation of an entry set that checks additions via setValue.
AbstractInputCheckedMapDecorator.EntrySetIterator	Implementation of an entry set iterator that checks additions via setValue.
AbstractInputCheckedMapDecorator.MapEntry	Implementation of a map entry that checks additions via setValue.
AbstractLinkedMap	An abstract implementation of a hash-based map that links entries to create an ordered map and which provides numerous points for subclasses to override.
AbstractLinkedMap.EntrySetIterator	EntrySet iterator.
AbstractLinkedMap.KeySetIterator	KeySet iterator.
AbstractLinkedMap.LinkEntry	LinkEntry that stores the data.
AbstractLinkedMap.LinkIterator	Base Iterator that iterates in link order.
AbstractLinkedMap.LinkMapIterator	MapIterator implementation.
AbstractLinkedMap.ValuesIterator	Values iterator.
AbstractMapDecorator	Provides a base decorator that enables additional functionality to be added to a Map via decoration.
AbstractOrderedMapDecorator	Provides a base decorator that enables additional functionality to be added to an OrderedMap via decoration.
AbstractReferenceMap	An abstract implementation of a hash-based map that allows the entries to be removed by the garbage collector.
AbstractReferenceMap.ReferenceEntry	A MapEntry implementation for the map.
AbstractReferenceMap.ReferenceEntrySet	EntrySet implementation.
AbstractReferenceMap.ReferenceEntrySetIterator	The EntrySet iterator.
AbstractReferenceMap.ReferenceKeySet	KeySet implementation.
AbstractReferenceMap.ReferenceKeySetIterator	The keySet iterator.
AbstractReferenceMap.ReferenceMapIterator	The MapIterator implementation.
AbstractReferenceMap.ReferenceValues	Values implementation.
AbstractReferenceMap.ReferenceValuesIterator	The values iterator.
AbstractReferenceMap.SoftRef	A soft reference holder.
AbstractReferenceMap.WeakRef	A weak reference holder.
AbstractSortedMapDecorator	Provides a base decorator that enables additional functionality to be added to a Map via decoration.
CaseInsensitiveMap	A case-insensitive `Map`.
CompositeMap	Decorates a map of other maps to provide a single unified view.
DefaultedMap	Decorates another `Map` returning a default value if the map does not contain the requested key.
FixedSizeMap	Decorates another `Map` to fix the size, preventing add/remove.
FixedSizeSortedMap	Decorates another `SortedMap` to fix the size blocking add/remove.
Flat3Map	A `Map` implementation that stores data in simple fields until the size is greater than 3.
Flat3Map.EntrySet	EntrySet
Flat3Map.EntrySetIterator	EntrySetIterator and MapEntry
Flat3Map.FlatMapIterator	FlatMapIterator
Flat3Map.KeySet	KeySet
Flat3Map.KeySetIterator	KeySetIterator
Flat3Map.Values	Values
Flat3Map.ValuesIterator	ValuesIterator
HashedMap	A `Map` implementation that is a general purpose alternative to `HashMap`.
IdentityMap	A `Map` implementation that matches keys and values based on `==` not `equals()`.
IdentityMap.IdentityEntry	HashEntry
LazyMap	Decorates another `Map` to create objects in the map on demand.
LazySortedMap	Decorates another `SortedMap` to create objects in the map on demand.
LinkedMap	A `Map` implementation that maintains the order of the entries.
LinkedMap.LinkedMapList	List view of map.
ListOrderedMap	Decorates a `Map` to ensure that the order of addition is retained using a `List` to maintain order.
ListOrderedMap.EntrySetView
ListOrderedMap.KeySetView
ListOrderedMap.ListOrderedIterator
ListOrderedMap.ListOrderedMapEntry
ListOrderedMap.ListOrderedMapIterator
ListOrderedMap.ValuesView
LRUMap	A `Map` implementation with a fixed maximum size which removes the least recently used entry if an entry is added when full.
MultiKeyMap	A `Map` implementation that uses multiple keys to map the value.
MultiValueMap	A MultiValueMap decorates another map, allowing it to have more than one value for a key.
MultiValueMap.ReflectionFactory	Inner class that provides a simple reflection factory.
PredicatedMap	Decorates another `Map` to validate that additions match a specified predicate.
PredicatedSortedMap	Decorates another `SortedMap` to validate that additions match a specified predicate.
ReferenceIdentityMap	A `Map` implementation that allows mappings to be removed by the garbage collector and matches keys and values based on `==` not `equals()`.
ReferenceMap	A `Map` implementation that allows mappings to be removed by the garbage collector.
SingletonMap	A `Map` implementation that holds a single item and is fixed size.
SingletonMap.SingletonMapIterator	SingletonMapIterator.
SingletonMap.SingletonValues	Values implementation for the SingletonMap.
StaticBucketMap	A StaticBucketMap is an efficient, thread-safe implementation of `java.util.Map` that performs well in in a highly thread-contentious environment.
StaticBucketMap.Lock	The lock object, which also includes a count of the nodes in this lock.
StaticBucketMap.Node	The Map.Entry for the StaticBucketMap.
TransformedMap	Decorates another `Map` to transform objects that are added.
TransformedSortedMap	Decorates another `SortedMap` to transform objects that are added.
TypedMap	Decorates another `Map` to validate that elements added are of a specific type.
TypedSortedMap	Decorates another `SortedMap` to validate that elements added are of a specific type.
UnmodifiableEntrySet	Decorates a map entry `Set` to ensure it can't be altered.
UnmodifiableEntrySet.UnmodifiableEntry	Implementation of a map entry that is unmodifiable.
UnmodifiableEntrySet.UnmodifiableEntrySetIterator	Implementation of an entry set iterator.
UnmodifiableMap	Decorates another `Map` to ensure it can't be altered.
UnmodifiableOrderedMap	Decorates another `OrderedMap` to ensure it can't be altered.
UnmodifiableSortedMap	Decorates another `SortedMap` to ensure it can't be altered.

Package org.apache.commons.collections.map Description

This package contains implementations of the Map, IterableMap, OrderedMap and SortedMap interfaces. A Map provides a lookup from a key to a value. A number of implementations also support the new MapIterator interface that enables simple iteration of map keys and values.

The following implementations are provided:

CaseInsensitiveMap - map that compares keys in a case insensitive way
CompositeMap - map that combines multiple maps into a single view
HashedMap - general purpose HashMap replacement supporting MapIterator
IdentityMap - map that uses == for comparison instead of equals()
Flat3Map - designed for good performance at size 3 or less
LinkedMap - a hash map that maintains insertion order, supporting OrderedMapIterator
MultiKeyMap - map that provides special methods for using more than one key to access the value
ReferenceMap - allows the garbage collector to collect keys and values using equals() for comparison
ReferenceIdentityMap - allows the garbage collector to collect keys and values using == for comparison
SingletonMap - a fully featured map to hold one key-value pair
StaticBucketMap - internally synchronized and designed for thread-contentious environments

The following decorators are provided:

Unmodifiable - ensures the collection cannot be altered
Predicated - ensures that only elements that are valid according to a predicate can be added
Typed - ensures that only elements that are of a specific type can be added
Transformed - transforms each element added
FixedSize - ensures that the size of the map cannot change
Lazy - creates objects in the map on demand
ListOrdered - ensures that insertion order is retained