Java Collection - Map

Map Interface

The Map interface is not an extension of Collection interface. Instead the interface starts of it’s own interface hierarchy, for maintaining key-value associations. The interface describes a mapping from keys to values, without duplicate keys, by defination.

The Map interface provides three collection views, which allow a map's contents to be viewed as a set of keys, collection of values, or set of key-value mappings. The order of a map is defined as the order in which the iterators on the map's collection views return their elements. Some map implementations, like the TreeMap class, make specific guarantees as to their order; others, like the HashMap class, do not.

Key-Value pairs

Key-value pairs are stored in maps.

Map interfaces

·        Map implemented by HashMap and TreeMap

·        SortedMap implemented by TreeMap.

·        Map.Entry which describes access methods to the key-value pairs.

Implementing classes

A number of classes implement the Map interface, including HashMap, TreeMap, LinkedHashMap, WeakHashMap, ConcurrentHashMap, and Properties. The most generally useful class is HashMap.

·         java.util.HashMap is implemented with a hash table. Access time is O(1). Entries are unsorted.

·         java.util.LinkedHashMap is implemented with a hash table. Access time is O(1). Entries are sorted in either entry order or order of last access, which is useful for implementing a LRU (least recently used) caching policy.

·         java.util.TreeMap is implemented as a balanced binary tree. Access time is O(log N). Entries are sorted.

HashMap

HashMap is not sorted or ordered. If you just need a Map, and you don’t care about the order of the elements while iterating through it, you can use a HashMap. That keeps it simple. The values can be null. But the key should ne unique, so you can have one null value for key. (Allows only one null key).

LinkedHashMap

LinkedHashMap will keep the order in which the elements are inserted into it. If you will be adding and removing elements a lot, it will be better to use HashMap, because LinkedHashMap will be slower to do those operations. But, you can iterate faster using LinkedHashMap. So, if you will be iterating heavily, it may be a good idea to use this.

WeakHashMap

A map of weak keys that allow objects referred to by the map to be released; designed to solve certain types of problems. If no references outside the map are held to a particular key, it may be garbage collected.

IdentityHashMap

A hash map that uses == instead of equals( ) to compare keys. Only for solving special types of problems;

not for general use.

Hashtable

Hashtable is almost the same as HashMap. The main differences are:

1. Hashtable does not let you have null value for key.

2. The key methods of Hashtable are synchronized. So, they may take a longer time to execute, compared to HashMap’s methods.

SortedMap

If you have a SortedMap (of which TreeMap is the only one available), the keys are guaranteed to be in sorted order, which allows additional functionality to be provided with these methods in the SortedMap interface:

Comparator comparator( ): Produces the comparator used for this Map, or null for natural ordering.

Object firstKey( ): Produces the lowest key.

Object lastKey( ): Produces the highest key.

SortedMap subMap(fromKey, toKey): Produces a view of this Map with keys from fromKey, inclusive, to toKey, exclusive.

SortedMap headMap(toKey): Produces a view of this Map with keys less than toKey.

SortedMap tailMap(fromKey): Produces a view of this Map with keys greater than or equal to fromKey.