Map interface in java

Map interface in java

Map is an object that maps keys to values.

A map cannot contain duplicate keys:.

Each key can map to at most one value.

The Map interface is not a true subtype of Collection interface, therefore, its characteristics and behaviors are different from the rest of the collection types.

It provides three collection views – set of keys, set of key-value mappings and collection of values.

A Map cannot contain duplicate keys and each key can map to at most one value. Some implementations allow null key and null value (HashMap and LinkedHashMap) but some does not (TreeMap).

The Map interface doesn’t guarantee the order of mappings, however, it depends on the implementation. For instance, HashMap doesn’t guarantee the order of mappings but TreeMap does.

AbstractMap class provides a skeletal implementation of the Java Map interface and most of the Map concrete classes extend AbstractMap class and implement required methods.

The Map interface includes methods for basic operations (such as putgetremovecontainsKeycontainsValuesize, and empty), bulk operations (such as putAll and clear), and collection views (such as keySetentrySet, and values).

Java Map Hierarchy

map interface methods

Modifier and Type Method and Description
void clear() Removes all of the mappings from this map (optional operation).
default V compute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction) Attempts to compute a mapping for the specified key and its current mapped value (or null if there is no current mapping).
default V computeIfAbsent(K key, Function<? super K,? extends V> mappingFunction) If the specified key is not already associated with a value (or is mapped to null), attempts to compute its value using the given mapping function and enters it into this map unless null.
default V computeIfPresent(K key, BiFunction<? super K,? super V,? extends V> remappingFunction) If the value for the specified key is present and non-null, attempts to compute a new mapping given the key and its current mapped value.
boolean containsKey(Object key) Returns true if this map contains a mapping for the specified key.
boolean containsValue(Object value) Returns true if this map maps one or more keys to the specified value.
Set<Map.Entry<K,V>> entrySet() Returns a Set view of the mappings contained in this map.
boolean equals(Object o) Compares the specified object with this map for equality.
default void forEach(BiConsumer<? super K,? super V> action) Performs the given action for each entry in this map until all entries have been processed or the action throws an exception.
V get(Object key) Returns the value to which the specified key is mapped, or null if this map contains no mapping for the key.
default V getOrDefault(Object key, V defaultValue) Returns the value to which the specified key is mapped, or defaultValue if this map contains no mapping for the key.
int hashCode() Returns the hash code value for this map.
boolean isEmpty() Returns true if this map contains no key-value mappings.
Set<K> keySet() Returns a Set view of the keys contained in this map.
default V merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction) If the specified key is not already associated with a value or is associated with null, associates it with the given non-null value.
V put(K key, V value) Associates the specified value with the specified key in this map (optional operation).
void putAll(Map<? extends K,? extends V> m) Copies all of the mappings from the specified map to this map (optional operation).
default V putIfAbsent(K key, V value) If the specified key is not already associated with a value (or is mapped to null) associates it with the given value and returns null, else returns the current value.
V remove(Object key) Removes the mapping for a key from this map if it is present (optional operation).
default boolean remove(Object key, Object value) Removes the entry for the specified key only if it is currently mapped to the specified value.
default V replace(K key, V value) Replaces the entry for the specified key only if it is currently mapped to some value.
default boolean replace(K key, V oldValue, V newValue) Replaces the entry for the specified key only if currently mapped to the specified value.
default void replaceAll(BiFunction<? super K,? super V,? extends V> function) Replaces each entry’s value with the result of invoking the given function on that entry until all entries have been processed or the function throws an exception.
int size() Returns the number of key-value mappings in this map.
Collection<V> values() Returns a Collection view of the values contained in this map.

 Implementations of Map

The Java platform contains three general-purpose Map implementations: HashMapTreeMap, and LinkedHashMap. Their behavior and performance are precisely similar to HashSetTreeSet, and LinkedHashSet

 import java.util.Collection;

import java.util.HashMap;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Set;

public class MapExample {

                public static void main(String[] args) {

                                Map<String, String> data = new HashMap<>();

                                data.put(“Mumbai”, “Maharshtra”); // put example

                                data.put(“Delhi”, “Delhi”);

                                data.put(“Chennai”, “Tamilnadu”);

                                data.put(“Kolkata”, “west-Bangal”);

                                data.put(null, “Goa”); // null key

        data.put(“Hyderabad”,null);// null value

                                String value = data.get(“Mumbai”); // get example

                                System.out.println(“Key = Mumbai, Value = ” + value);

                                value = data.getOrDefault(“Banglore”,”Default Value”);

                                System.out.println(“Key = Banglore, Value=” + value);

                                boolean keyExists = data.containsKey(null);

                                boolean valueExists = data.containsValue(700001);

                                System.out.println(“keyExists= ” + keyExists + “, valueExists= ” + valueExists);

                                Set<Entry<String, String>> entrySet = data.entrySet();

                                System.out.println(entrySet);

                                System.out.println(“data map size=” + data.size());

                                Map<String, String> data1 = new HashMap<>();

                                data1.putAll(data);

                                System.out.println(“data1 mappings= ” + data1);

                                String nullKeyValue = data1.remove(null);

                                System.out.println(“data1 null key value = ” + nullKeyValue);

                                System.out.println(“data1 after removing null key = ” + data1);

                                Set<String> keySet = data.keySet();

                                System.out.println(“data map keys = ” + keySet);

                                Collection<String> values = data.values();

                                System.out.println(“data map values = ” + values);

                                data.clear();

                                System.out.println(“data map is empty =” + data.isEmpty());

                }

output

Key = Mumbai, Value = Maharshtra
Key = Banglore, Value=Default Value 
keyExists= true, valueExists= false [null=Goa, Delhi=Delhi, Chennai=Tamilnadu, Kolkata=west-Bangal, Mumbai=Maharshtra, Hyderabad=null] 
data map size=6 
data1 mappings= {null=Goa, Delhi=Delhi, Chennai=Tamilnadu, Kolkata=west-Bangal, Mumbai=Maharshtra, Hyderabad=null} 
data1 null key value = Goa 
data1 after removing null key = {Delhi=Delhi, Chennai=Tamilnadu, Kolkata=west-Bangal, Mumbai=Maharshtra, Hyderabad=null} 
data map keys = [null, Delhi, Chennai, Kolkata, Mumbai, Hyderabad] 
data map values = [Goa, Delhi, Tamilnadu, west-Bangal, Maharshtra, null] 
data map is empty =true 

Leave a Reply