# Package org.apache.commons.collections4.map

package org.apache.commons.collections4.map
Implements 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

- Related Packages
  Package
  Description
  org.apache.commons.collections4
  Interfaces and utilities shared across all packages.
- 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.
  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.ReferenceEntry<K,V>
  A MapEntry implementation for the map.
  AbstractReferenceMap.ReferenceStrength
  Enumerates reference types.
  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.
  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.
  ConcurrentReferenceHashMap<K,V>
  An advanced hash map supporting configurable garbage collection semantics of keys and values, optional referential-equality, full concurrency of retrievals, and adjustable expected concurrency for updates.
  ConcurrentReferenceHashMap.Builder<K,V>
  Builds new ConcurrentReferenceHashMap instances.
  ConcurrentReferenceHashMap.Option
  Behavior-changing configuration options for the map
  ConcurrentReferenceHashMap.ReferenceType
  An option specifying which Java reference type should be used to refer to a key and/or value.
  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.
  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.
  ListOrderedMap<K,V>
  Decorates a `Map` to ensure that the order of addition is retained using a `List` to maintain order.
  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>
  Deprecated.
  since 4.1, use `MultiValuedMap` instead
  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 an expiration time that is a constant about of time in the future from the current time.
  PassiveExpiringMap.ExpirationPolicy<K,V>
  A policy to determine the expiration time for key-value entries.
  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.
  StaticBucketMap<K,V>
  A StaticBucketMap is an efficient, thread-safe implementation of `Map` that performs well in a highly thread-contentious environment.
  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.