org.apache.commons.collections4.map

Interface Summary
Interface	Description
CompositeMap.MapMutator<K,V>	This interface allows definition for all of the indeterminate mutators in a CompositeMap, as well as providing a hook for callbacks on key collisions.
PassiveExpiringMap.ExpirationPolicy<K,V>	A policy to determine the expiration time for key-value entries.

Class Summary
Class	Description
AbstractHashedMap<K,V>	An abstract implementation of a hash-based map which provides numerous points for subclasses to override.
AbstractHashedMap.EntrySet<K,V>	EntrySet implementation.
AbstractHashedMap.EntrySetIterator<K,V>	EntrySet iterator.
AbstractHashedMap.HashEntry<K,V>	HashEntry used to store the data.
AbstractHashedMap.HashIterator<K,V>	Base Iterator
AbstractHashedMap.HashMapIterator<K,V>	MapIterator implementation.
AbstractHashedMap.KeySet<K>	KeySet implementation.
AbstractHashedMap.KeySetIterator<K>	KeySet iterator.
AbstractHashedMap.Values<V>	Values implementation.
AbstractHashedMap.ValuesIterator<V>	Values iterator.
AbstractInputCheckedMapDecorator<K,V>	An abstract base class that simplifies the task of creating map decorators.
AbstractIterableMap<K,V>	Provide a basic `IterableMap` implementation.
AbstractLinkedMap<K,V>	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<K,V>	EntrySet iterator.
AbstractLinkedMap.KeySetIterator<K>	KeySet iterator.
AbstractLinkedMap.LinkEntry<K,V>	LinkEntry that stores the data.
AbstractLinkedMap.LinkIterator<K,V>	Base Iterator that iterates in link order.
AbstractLinkedMap.LinkMapIterator<K,V>	MapIterator implementation.
AbstractLinkedMap.ValuesIterator<V>	Values iterator.
AbstractMapDecorator<K,V>	Provides a base decorator that enables additional functionality to be added to a Map via decoration.
AbstractOrderedMapDecorator<K,V>	Provides a base decorator that enables additional functionality to be added to an OrderedMap via decoration.
AbstractReferenceMap<K,V>	An abstract implementation of a hash-based map that allows the entries to be removed by the garbage collector.
AbstractReferenceMap.ReferenceBaseIterator<K,V>	Base iterator class.
AbstractReferenceMap.ReferenceEntry<K,V>	A MapEntry implementation for the map.
AbstractReferenceMap.ReferenceEntrySet<K,V>	EntrySet implementation.
AbstractReferenceMap.ReferenceEntrySetIterator<K,V>	The EntrySet iterator.
AbstractReferenceMap.ReferenceKeySet<K>	KeySet implementation.
AbstractReferenceMap.ReferenceKeySetIterator<K>	The keySet iterator.
AbstractReferenceMap.ReferenceMapIterator<K,V>	The MapIterator implementation.
AbstractReferenceMap.ReferenceValues<V>	Values implementation.
AbstractReferenceMap.ReferenceValuesIterator<V>	The values iterator.
AbstractReferenceMap.SoftRef<T>	A soft reference holder.
AbstractReferenceMap.WeakRef<T>	A weak reference holder.
AbstractSortedMapDecorator<K,V>	Provides a base decorator that enables additional functionality to be added to a Map via decoration.
AbstractSortedMapDecorator.SortedMapIterator<K,V>	OrderedMapIterator implementation.
CaseInsensitiveMap<K,V>	A case-insensitive `Map`.
CompositeMap<K,V>	Decorates a map of other maps to provide a single unified view.
DefaultedMap<K,V>	Decorates another `Map` returning a default value if the map does not contain the requested key.
EntrySetToMapIteratorAdapter<K,V>	Adapts a Map entrySet to the MapIterator interface.
FixedSizeMap<K,V>	Decorates another `Map` to fix the size, preventing add/remove.
FixedSizeSortedMap<K,V>	Decorates another `SortedMap` to fix the size blocking add/remove.
Flat3Map<K,V>	A `Map` implementation that stores data in simple fields until the size is greater than 3.
Flat3Map.EntryIterator<K,V>
Flat3Map.EntrySet<K,V>	EntrySet
Flat3Map.EntrySetIterator<K,V>	EntrySetIterator and MapEntry
Flat3Map.FlatMapEntry<K,V>
Flat3Map.FlatMapIterator<K,V>	FlatMapIterator
Flat3Map.KeySet<K>	KeySet
Flat3Map.KeySetIterator<K>	KeySetIterator
Flat3Map.Values<V>	Values
Flat3Map.ValuesIterator<V>	ValuesIterator
HashedMap<K,V>	A `Map` implementation that is a general purpose alternative to `HashMap`.
LazyMap<K,V>	Decorates another `Map` to create objects in the map on demand.
LazySortedMap<K,V>	Decorates another `SortedMap` to create objects in the map on demand.
LinkedMap<K,V>	A `Map` implementation that maintains the order of the entries.
LinkedMap.LinkedMapList<K>	List view of map.
ListOrderedMap<K,V>	Decorates a `Map` to ensure that the order of addition is retained using a `List` to maintain order.
ListOrderedMap.EntrySetView<K,V>
ListOrderedMap.KeySetView<K>
ListOrderedMap.ListOrderedIterator<K,V>
ListOrderedMap.ListOrderedMapEntry<K,V>
ListOrderedMap.ListOrderedMapIterator<K,V>
ListOrderedMap.ValuesView<V>
LRUMap<K,V>	A `Map` implementation with a fixed maximum size which removes the least recently used entry if an entry is added when full.
MultiKeyMap<K,V>	A `Map` implementation that uses multiple keys to map the value.
MultiValueMap<K,V>	A MultiValueMap decorates another map, allowing it to have more than one value for a key.
MultiValueMap.ReflectionFactory<T extends java.util.Collection<?>>	Inner class that provides a simple reflection factory.
PassiveExpiringMap<K,V>	Decorates a `Map` to evict expired entries once their expiration time has been reached.
PassiveExpiringMap.ConstantTimeToLiveExpirationPolicy<K,V>	A `ExpirationPolicy` that returns a expiration time that is a constant about of time in the future from the current time.
PredicatedMap<K,V>	Decorates another `Map` to validate that additions match a specified predicate.
PredicatedSortedMap<K,V>	Decorates another `SortedMap` to validate that additions match a specified predicate.
ReferenceIdentityMap<K,V>	A `Map` implementation that allows mappings to be removed by the garbage collector and matches keys and values based on `==` not `equals()`.
ReferenceMap<K,V>	A `Map` implementation that allows mappings to be removed by the garbage collector.
SingletonMap<K,V>	A `Map` implementation that holds a single item and is fixed size.
SingletonMap.SingletonMapIterator<K,V>	SingletonMapIterator.
SingletonMap.SingletonValues<V>	Values implementation for the SingletonMap.
StaticBucketMap<K,V>	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<K,V>	The Map.Entry for the StaticBucketMap.
TransformedMap<K,V>	Decorates another `Map` to transform objects that are added.
TransformedSortedMap<K,V>	Decorates another `SortedMap` to transform objects that are added.
UnmodifiableEntrySet<K,V>	Decorates a map entry `Set` to ensure it can't be altered.
UnmodifiableMap<K,V>	Decorates another `Map` to ensure it can't be altered.
UnmodifiableOrderedMap<K,V>	Decorates another `OrderedMap` to ensure it can't be altered.
UnmodifiableSortedMap<K,V>	Decorates another `SortedMap` to ensure it can't be altered.

Enum Summary
Enum Description

AbstractReferenceMap.ReferenceStrength
Reference type enum.

Enum Summary
Enum	Description
AbstractReferenceMap.ReferenceStrength	Reference type enum.

Package org.apache.commons.collections4.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
Flat3Map - designed for good performance at size 3 or less
LinkedMap - a hash map that maintains insertion order, supporting OrderedMapIterator
LRUMap - a hash map that maintains a maximum size by removing the least recently used entries
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
Transformed - transforms each element added
FixedSize - ensures that the size of the map cannot change
Defaulted - provides default values for non-existing keys
Lazy - creates objects in the map on demand
ListOrdered - ensures that insertion order is retained

Version:: $Id: package-info.java 1469004 2013-04-17 17:37:03Z tn $