A map whose mappings are automatically sorted by key,
either using the natural ordering of the keys or by a
comparator provided when a SortedMap instance is created.
Extends the Map interface.

A mapping from keys to values.
Each key can map to one value.

A SortedMap extended with navigation methods returning
the closest matches for given search targets.
A NavigableMap can be accessed and traversed in
either ascending or descending key order.

A Map with atomic putIfAbsent, remove, and replace methods.

A ConcurrentMap that is also a NavigableMap.

Skeletal Map implementation.

Hash table implementation of the Map interface
(an unsynchronized Hashtable that supports null keys and values).
The best all-around implementation of the Map interface.

A high-performance Map implementation backed by an array.
All keys in each EnumMap instance must be elements of a single enum type.

Synchronized hash table implementation of the Map interface
that does not allow null keys or values, plus additional legacy methods.

Red-black tree implementation of the NavigableMap interface.

Hash table and linked list implementation of the Map interface.
An insertion-ordered Map implementation that runs nearly as fast as HashMap.
Also useful for building caches

Identity-based Map implementation based on a hash table.
This class is useful for topology-preserving object graph transformations
(such as serialization or deep copying).

An implementation of the Map interface that stores only weak references to its keys.
Storing only weak references enables key-value pairs to be
garbage collected when the key is no longer referenced outside of the WeakHashMap.

A highly concurrent, high-performance ConcurrentMap implementation based on a hash table
It is intended as a drop-in replacement for Hashtable.
In addition to implementing ConcurrentMap, it supports all of the legacy methods of Hashtable.

Skips list implementation of the ConcurrentNavigableMap interface.

The Properties class represents a persistent set of properties.
The Properties can be saved to a stream or loaded from a stream.

Obsolete

Concurrent

extends

extends

extends

extends

extends

implements

extends

implements

extends

implements

extends

extends

extends

implements

extends

extends