Map<E> interface, its sub interfaces points and its methods

============================================================
1) Map is a root interface of map hierarchy.
The collection with mappings.

2) It is part of Collections Framework available from Java 1.2v

3) If we want to store objects with mappings, it means

if we want to store (key, value) pair table format
we must choose Map interface and its implementation classes.

4) Map interface does not maintain insertion order*

and does not have index.

5) Map interface has one sub interface

that is SortedMap and its has
another sub interface that is NavigableMap

6) SortedMap interface is for storing entries

in keys based sorting order. It is also available from Java 1.2v

7) NavigableMap is given from Java 6v, for adding

more navigation methods to SortedMap.

8) Map interface has 7 implemented classes (5 are CF classes and 2 are legacy
classes)
HashMap<K,V>, LinkedHashMap<K,V>, EnumMap<K,V>
WeakHashMap<K,V>, IdentityHashMap<K,V>
Hashtable<K,V>, Properties

9) SortedMap and NavigableMap has only one implementation class

TreeMap<K, V>

===========================================================================
Map<K, V>

SortedMap<K,V>

NavigableMap<K,V>

===========================================================================
AbatractMap<K,V> Dictionary<K,V>

===========================================================================

TreeMap<K,V> HashMap<K,V> EnumMap<K,V>

Hashtable<K,V>

LinkedHashMap<K,V> WeakHashMap<K,V>
Properties

IdentityHashMap<K,V>

===========================================================================
-> We must choose Hashtable<K,V> to store only unique entries
in multithreaded application with thread safety. HashMap is the
 alternative class for Hashtable. HashMap is given without thread
safety

Hashtable does not maintain insertion order. Internally it

stores entries in keys hash code order that is returned by
Object.hashCode() method either from current adding key class or
from java.lang.Object class.

-> We must choose HashMap<K,V> to store only unique entries

in single thread application or in method local operation
without worrying about insertion order. Internally it
stores entries in keys hash code order that is returned by
Object.hashCode() method either from current adding key class or
from java.lang.Object class.

-> We must choose LinkedHashMap<K,V> to store only unique entries

in insertion order.

-> We must choose WeakHashMap<K,V> to store only unique entries

with weak references, it means if we want to remove entries by
garbage collector
when there is no external references to keys we must choose
WeakHashMap<k, V>

-> We must choose IdentityHashMap<K,V> to store only unique entries

based on key object reference wise hash code only. It means like
other maps
this map does not use Object class hashCode() method, instead it
uses
System.identityHashCode(key)

-> We must choose EnumMap<K,V> to store only one enum's Named constants
as keys and any type of object as values.

-> We must choose TreeMap<K,V> for storing entries in sorting order(ASE

or DESC)
based on keys natural sorting order or given custom sorting order

-> We must choose Properties to store only string based unique entries
as a property name and value for storing them permanently in a
file
and later reading them from a file.

Map<E> methods ()
===================================================================================
=
1) finding empty or not
public boolean isEmpty()

2) adding one entry

public V put(K k, V v)

3) adding multiple entries

public void putAll(Map<? extends K, ? extends V> map)

4) searching for key

public boolean containsKey(K k)

5) searching for value

 public boolean containsValue(V v)

6) removing one entry

public V remove(Object k)

7) removing all entries and making Map empty

public void clear()

8) counting objects
public int size()

9) retrieving only value

public V get(K k)

10) retrieving all keys

public Set<K> keySet()

11) retrieving all values

public Collection<V> values()

12) retrieving all entries

public Set<Map.Entry<K, V>> entrySet()

13) retrieving hash code of this collection

public int hashCode()

14) comparing two collections

public boolean equals(Object obj)

+ Java 8v new methods +

15) public default V putIfAbsent(K key, V value)

16) public default V merge(K key,V value, BiFunction<? super V,?

super V,? extends V> remappingFunction)
17) public default V compute(K key, BiFunction<? super K,? super V,?
extends V> remappingFunction)
18) public default V computeIfPresent(K key,BiFunction<? super K,?
super V,? extends V> remappingFunction)
19) public default V computeIfAbsent(K key,Function<? super K,?
extends V> mappingFunction)

20) public default V replace(K key, V value)

21) public default boolean replace(K key, V oldValue, V newValue)
22) public default void replaceAll(BiFunction<? super K,? super
V,? extends V> function)

23) public default boolean remove(Object key, Object value)

24) public default V getOrDefault(Object key, V defaultValue)

25) public default void forEach(BiConsumer<? super K,? super V> action)

+ Java 9 methods +

26) Creating unmodifiable (immutable) collection with given elements

public static <K,V> Map<K,V> of();
public static <K,V> Map<K,V> of(K k1, V v1)
 public static <K,V> Map<K,V> of(K k1, V v1, K k2, V v2)
public static <K,V> Map<K,V> of(K k1, V v1, K k2, V v2, K k3, V v3)
public static <K,V> Map<K,V> of(K k1, V v1, K k2, V v2, K k3, V v3, K
k4, V v4)
public static <K,V> Map<K,V> of(K k1, V v1, K k2, V v2, K k3, V v3, K
k4, V v4, K k5, V v5)
public static <K,V> Map<K,V> of(K k1, V v1, K k2, V v2, K k3, V v3, K
k4, V v4, K k5, V v5, K k6, V v6)
public static <K,V> Map<K,V> of(K k1, V v1, K k2, V v2, K k3, V v3, K
k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7)
public static <K,V> Map<K,V> of(K k1, V v1, K k2, V v2, K k3, V v3, K
k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8)
public static <K,V> Map<K,V> of(K k1, V v1, K k2, V v2, K k3, V v3, K
k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8)
public static <K,V> Map<K,V> of(K k1, V v1, K k2, V v2, K k3, V v3, K
k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9)
public static <K,V> Map<K,V> of(K k1, V v1, K k2, V v2, K k3, V v3, K
k4, V v4, K k5, V v5, K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10)
public static <K,V> Map<K,V> ofEntries(Map.Entry<? extends K,? extends
V>... entries)

public static <K,V> Map.Entry<K,V> entry(K k,V v)

+ Java 10 method +

27) Creating unmodifiable (immutable) Map with the entries of given map

public static <K,V> Map<K,V> copyOf(Map<? extends K,? extends V> map)