Skip to content

AvinandanBose/Java-Collections-Map

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Repository files navigation

Java Collections Map

Here is all about Map of Java

1. AbstractMap[Abstract Class]

  • 1. Every class of Java is inherited from java.lang.Object

  • 2. The AbstractMap class is the base class of the map classes in Java.

  • sequenceDiagram
        
      
      java.lang.Object->>java.util.AbstractMap: 
    
    
    Loading
  • 3. The AbstractMap class is a part of the Java Collection Framework.

  • 4. It directly implements the Map interface to provide a structure to it.

  • 5. AbstractMap is an abstract class, hence we cannot create AbstractMap's Object but the concrete classes that inherit from AbstractMap can be used to create objects .


  • Interface Hash Table Resizable Array Balanced Tree Linked List
    Map HashMap TreeMap
    SortedMap TreeMap
    NavigableMap TreeMap
    Map.Entry(Inner Class of Map)

    public abstract class AbstractMap<K,V> extends Object, implements Map<K,V>
    

    Methods of Abstract Map(Abstract Class)

      Methods of Abstract Map(Abstract Class) Does This
      1. clear() Removes all of the mappings from this map .
      2.clone() Returns a shallow copy of this map.
      3. containsKey(Object key) Returns true if this map contains a mapping for the specified key.
      4. containsValue(Object value) Returns true if this map maps one or more keys to the specified value.
      5.entrySet() Returns a Set view of the mappings contained in this map.
      6. equals(Object o) Compares the specified object with this map for equality.
      7. get(Object key) Returns the value to which the specified key is mapped, or null if this map contains no mapping for the key.
      8. hashCode() Returns the hash code value for this map.
      9. isEmpty() Returns true if this map contains no key-value mappings.
      10. keySet() Returns a Set view of the keys contained in this map.
      11. put(K key, V value) Associates the specified value with the specified key in this map .
      12. putAll(Map m) Copies all of the mappings from the specified map to this map .
      13. remove(Object key) Removes the mapping for a key from this map if it is present.
      14.size() Returns the number of key-value mappings in this map.
      15.toString() Returns a string representation of this map.
      16.values() Returns a Collection view of the values contained in this map.

      Note: These methods are discussed below .

A. Map - Interface

  • 1. A map stores data in Key/Value pairs much like an array.

  • 2. Every Key/Value pairs stored in indexes .

  • 3. Every Key/Value pairs are stored as Objects in Java.

  • 4. Typically , keys are Strings.

  • 5. Given a Key and a Value, we can store the value in a Map object.

  • 6. After the value is stored , we can retrieve it by using its Key.

  • 7. Map is generic and is declared :

  • interface Map<K,V>
    

    Where, K specifies the type of keys and V specifies the type of values.

  • 8. Map do not implement the Iterable interface. Futhermore Iterator also cannot be obtained by a map.

    • That is :
      
      import java.util.Iterator;
      import  java.lang.Iterable;
      
      Iterable<Map<Key, Value>> itr = map; → Cannot be Obtained
      
      Or
      
      Iterator<Map<Key, Value>> iterator = map.iterator(); → Cannot be Obtained
      
    Interface Description
    Map Maps unique keys to values.
    Map.Entry Describes an element (a key/value) in a map. This is an inner class of Map.
    NavigableMap It extends SortedMap to handle the retrieval of entries based on closest-match searches.
    SortedMap It extends Map to keep the keys in ascending order.

Methods of Map Interface

    Methods of Map Interface Does This
    1. clear() Removes all of the mappings from this map
    2. compute(K key, BiFunction remappingFunction) Attempts to compute a mapping for the specified key and its current mapped value (or null if there is no current mapping).
    3. computeIfAbsent(K key, Function 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.
    4. computeIfPresent(K key, BiFunction 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.
    5. containsKey(Object key) Returns true if this map contains a mapping for the specified key.
    6. containsValue(Object value) Returns true if this map maps one or more keys to the specified value.
    7. entrySet() Returns a Set view of the mappings(All Entries) contained in this map.
    8. equals(Object o) Compares the specified object with this map for equality.
    9. forEach(BiConsumer action) Performs the given action for each entry in this map until all entries have been processed or the action throws an exception.
    10. get(Object key) Returns the value to which the specified key is mapped, or null if this map contains no mapping for the key.
    11. 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.
    12. hashCode() Returns the hash code value for this map.
    13. isEmpty() Returns true if this map contains no key-value mappings.
    14.keySet() Returns a Set view of the keys contained in this map.
    15.merge(K key, V value, BiFunction 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.
    16.put(K key, V value) Associates the specified value with the specified key in this map.
    17.putAll(Map m) Copies all of the mappings from the specified map to this map.
    18.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.
    19.remove(Object key) Removes the mapping for a key from this map if it is present.
    20.remove(Object key, Object value) Removes the entry for the specified key only if it is currently mapped to the specified value.
    21.replace(K key, V value) Replaces the entry for the specified key only if it is currently mapped to some value.
    22.replace(K key, V oldValue, V newValue) Replaces the entry for the specified key only if currently mapped to the specified value.
    23.replaceAll(BiFunction 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.
    24.size() Returns the number of key-value mappings in this map.
    25.values() Returns a Collection view of the values contained in this map.

    Note: These methods are discussed below .

3. HashMap

    1. HashMap extends Abstract Map abstract class.

    2. As Abstract Map implements Map interface and extends java.lang.Object class , HashMap inherits all of their functions.

  • 3. And most imported thing : "The HashMap provides us an unsorted, unordered Map ".

  • 4. HashMap has implementation based on a Hash table.

  • 5. Duplicate keys are not allowed i.e. Keys are unique .

  • 6. Whereas, Duplicate values can be present / allowed .

  •   
     graph TD;
        Object-->|extends| AbstractMap;
        Map-->|implements| AbstractMap;
        AbstractMap-->|extends| HashMap;
    
    
    Loading

    Constructors of HashMap

    :ThresHold of HashMap, Capacity and LoadFactor:
    --------------------------------------------------
    
    ThresHold of HashMap : 
    The threshold of a HashMap is approximately the product of current capacity and load factor
    
    LoadFactor : 
    The load factor is the measure that decides when to increase the capacity of the Map.
    
    Capacity of HashMap: 
    Capacity is the number of buckets in the HashMap. 
    
    Default Capacity of HashMap: 16
    That is empty HashMap created with capacity 16.
    
    Default LoadFactor of HashMap: 0.75
    That is empty HashMap created with Load Factor 0.75.
    
    Default Threshold of HashMap: is 16 * 0.75 = 12.
    That is empty HashMap created with threshold 12.
    

    HashMapStructure-660x545

    Extras:

    Index: 
    It is the integer value .
    It is obtained after performing → 
    Bitwise AND operation on the Value of Hash of the Key and Array Size Minus One.
    
    i.e., :| Index = hashcode(key) & (ArraySize – 1) |:
    
    
    Bucket: It is a LinkedList structure of nodes.
    
    
    Node: It is the elementary unit of a HashMap. 
    It contains the key-value pair and a link to the next node.
    
    Next: Link to the next node.
    
    It is represented as:  Node<K,V> next.
    
    Where K represents Key and V represents Value.
    
    Rehashing: It is the process of doubling the capacity of the HashMap ,
    after it reaches its Threshold. In java, HashMap continues to 
    rehash(by default) in the following sequence – 2^4, 2^5, 2^6, 2^7, …. so on. 
    
    
    
    

    node_hash_map

    Methods of HashMap

      It removes all the mappings of this map.
      The map will be empty after this call returns.
      
      Returns a shallow copy of the HashMap instance provided for cloning
      but the keys and values themselves are not cloned.
      
      Returns true if this map contains a mapping for the specified key.
      
      Returns true if this map maps one or more keys to the specified value.
      
      Performs the given action for each entry in this map 
      until all entries have been processed or the action throws an exception.
      
      Syntax: get(key: Key)
      
      Returns the value to which the specified key is mapped, 
      or null if this map contains no mapping for the key.
      
      Syntax: getOrDefault(key: Key , defaultValue:Value)
      
      Returns the value to which the specified key is mapped, 
      or defaultValue if this map contains no mapping for the key.
      
      i.e.,getOrDefault(key:"One" , defaultValue:1)
      then it will return the value for the key : "One"
      Or, it will return the value for the value : 1
      
      Most priority given or first search is Key for Value .
      If not found , then it searches for defaultValue for value.
      
      That is if "One" is not found then it searches for 1.
      Returns true if this map contains no key-value mappings.
      Returns a Set view of the keys contained in this map. 
      The set is backed by the map, 
      so changes to the map are reflected in the set, and vice-versa.
      
      Note:
      As Set<K> keySet()→ Is a Function that returns Set,
      Hence, it call all those functions that Set contains,
      Such as:
      →forEach
      →toArray()
      →remove()
      →removeIf()
      →retainAll()
      →removeAll()
      →Stream()
      →ParallelStream()
      →spliterator()
      →iterator()
      →contains()
      →containsAll()
      ...etc.
      
      It does not support the add or addAll operations.
      Associates the specified value with the specified key in this map. 
      If the map previously contained a mapping for the key, 
      the old value is replaced.
      Copies all of the mappings from the specified map to this map. 
      These mappings will replace any mappings that this map had ,
      for any of the keys currently in the specified map.
      Removes the mapping for the specified key from this map if present.
      Removes the entry for the specified key only if it is currently mapped to the specified value.
      Replaces the entry for the specified key only if currently mapped to the specified value.
      It replaces old value with new value.
      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.
      Returns the number of key-value mappings in this map.
      Returns a Collection view of the values contained in this map.
      
      Note:
      Iterator.remove
      Iterator.hasNext()
      Iterator.next()
      Collection.remove, 
      Collection.removeAll, 
      Collection.removeIf,
      Collection.retainAll and 
      Collection.clear 
      
      like selected operations is performed,
      as it returns a Collection.
      
      Except:
      
      It does not support the add or addAll operations.
      If the specified key is not already associated with a value ,
      then associates it with the given value .
      
      If the specified key is not already associated with a value,
      and now the new value mapped with the new key is NULL , 
      then it will return null. 
      Attempts to compute a mapping for the specified key and 
      its current mapped value (or null if there is no current mapping).
      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.
      
      If the mapping function returns null, no mapping is recorded.
      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.
      
      If the remapping function returns null, the mapping is removed.
      Returns a Set view of the mappings contained in this map. 
      The set is backed by the map, 
      so changes to the map are reflected in the set, 
      and vice-versa. 
      
      
      As entrySet()→ Is a Function that returns Set,
      Hence, it call all those functions that Set contains,
      Such as:
      →forEach
      →toArray()
      →remove()
      →removeIf()
      →retainAll()
      →removeAll()
      →Stream()
      →ParallelStream()
      →spliterator()
      →iterator()
      →contains()
      →containsAll()
      ...etc.
      
      It does not support the add or addAll operations.
      If the specified key is not already associated with a value
      or is associated with null, associates it with the given non-null value. 
      Otherwise, replaces the associated value with the results of the given remapping function, 
      or removes if the result is null. 
      
      This method may be of use when combining multiple mapped values for a key.
      Replaces the entry for the specified key only if it is currently mapped to some value.
      Methods Does This
      1. Clear It removes all of the mappings from the map.
      2.Clone It gets a copy of this HashMap instance
      3.containsKey Returns true if this map contains a mapping for the specified key.
      4.containsValue Returns true if this map maps one or more keys to the specified value.
      5.forEach Performs the given action for each entry in this map until all entries have been processed or the action throws an exception.
      6.get(key: Key) Returns the value to which the specified key is mapped, or null if this map contains no mapping for the key.
      7.getOrDefault(key: Key , defaultValue:Value) Returns the value to which the specified key is mapped, or defaultValue if this map contains no mapping for the key.
      8.isEmpty Returns true if this map contains no key-value mappings.
      9.KeySet Returns a Set view of the keys contained in this map. The set is backed by the map, so changes to the map are reflected in the set, and vice-versa.If the map is modified while an iteration over the set is in progress (except through the iterator's own remove operation), the results of the iteration are undefined. The set supports element removal, which removes the corresponding mapping from the map, via the Iterator.remove, Set.remove, removeAll, retainAll, and clear operations. It does not support the add or addAll operations.
      10.Put Associates the specified value with the specified key in this map. If the map previously contained a mapping for the key, the old value is replaced.
      11.PutAll Copies all of the mappings from the specified map to this map. These mappings will replace any mappings that this map had , for any of the keys currently in the specified map.
      12.Remove(key: Key) Removes the mapping for the specified key from this map if present.
      13.Remove(key: Key, value:Value) Removes the entry for the specified key only if it is currently mapped to the specified value.
      14.Replace(key: Key, oldValue:Value, newValue:Value) Replaces the entry for the specified key only if currently mapped to the specified value. It replaces old value with new value.
      15.ReplaceAll(BiFunction 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.
      16.Size() Returns the number of key-value mappings in this map.
      17.values() Returns a Collection view of the values contained in this map.
      18.putIfAbsent() If the specified key is not already associated with a value , then associates it with the given value .
      19.compute(key:Key,BiFunction function) Attempts to compute a mapping for the specified key and its current mapped value (or null if there is no current mapping).
      20.computeIfAbsent(key:Key, MappingFunction function) 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.

      If the mapping function returns null, no mapping is recorded.

      21.computeIfPresent(key:Key, BiFunction function) 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.

      If the remapping function returns null, the mapping is removed.

      22.entrySet() Returns a Set view of the mappings contained in this map. The set is backed by the map, so changes to the map are reflected in the set, and vice-versa. If the map is modified while an iteration over the set is in progress (except through the iterator's own remove operation, or through the setValue operation on a map entry returned by the iterator) the results of the iteration are undefined. The set supports element removal, which removes the corresponding mapping from the map, via the Iterator.remove, Set.remove, removeAll, retainAll and clear operations.It does not support the add or addAll operations.
      23.merge(key:Key, value:Value, BiFunction 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. Otherwise, replaces the associated value with the results of the given remapping function, or removes if the result is null.

      This method may be of use when combining multiple mapped values for a key.

      24.Replace(key:Key, value:Value) Replaces the entry for the specified key only if it is currently mapped to some value.

    Methods inherited from class java.util.AbstractMap

      Compares the specified object with this map for equality. 
      Returns true if the given object is also a map and the two maps represent the same mappings. 
      
      More formally, two maps m1 and m2 represent the same mappings,
      if m1.entrySet().equals(m2.entrySet()).
      Returns a string representation of this map. 
      Returns the hash code value for this map. 
      Methods Does This
      1.equals() Compares the specified object with this map for equality. Returns true if the given object is also a map and the two maps represent the same mappings.
      2.toString() Returns a string representation of this map.
      3.hashCode() Returns the hash code value for this map.

    Note: Map interface →java.util.Map contains: equals(), forEach(), getOrDefault(), hashCode(), putIfAbsent(), remove(), replace(), replaceAll() functions inherited by HashMap() have same actions in program .

Division of Abstract Map

     
     graph TD;
        Map-->|implements| AbstractMap;
        AbstractMap-->|extends| HashMap;
        AbstractMap-->|extends| IdentityHashMap;
        AbstractMap-->|extends| WeakHashMap;
        AbstractMap-->|extends| TreeMap;
        AbstractMap-->|extends| EnumMap;
        AbstractMap-->|extends| ConcurrentHashMap;
        AbstractMap-->|extends| ConcurrentSkipListMap;
        AbstractMap-->|extends| Object;
        ConcurrentHashMap-->|implements| ConcurrentMap;
        ConcurrentSkipListMap-->|implements| ConcurrentNavigableMap;
        HashMap-->|extends| LinkedHashMap; 
        ConcurrentMap-->|extends| Map;
        Map-->|extends| SortedMap;
        SortedMap-->|extends| NavigableMap;
        TreeMap-->|implements| NavigableMap;
        ConcurrentNavigableMap-->|extends| ConcurrentMap;
        ConcurrentNavigableMap-->|extends| NavigableMap;
        HashTable-->|implements|Map
    
    Loading

Linked Hash Map

    sequenceDiagram
        
      
      java.util.Map->>java.util.HashMap:implements 
      java.util.HashMap->>java.util.LinkedHashMap:extends
      
      
    
    Loading
  • 1. A LinkedHashMap is an extension of the HashMap class and it implements the Map interface.

  • public class LinkedHashMap<K,​V> extends HashMap<K,​V> implements Map<K,​V>
    

  • 2.The implementation of the LinkedHashMap is very similar to a doubly-linked list. Therefore, each node of the LinkedHashMap is represented as:

  • Screenshot (197)

    • Hash: All the input keys are converted into a hash which is a shorter form of the key so that the search and insertion are faster.

    • Key: Since this class extends HashMap, the data is stored in the form of a key-value pair. Therefore, this parameter is the key to the data.

    • Value: For every key, there is a value associated with it. This parameter stores the value of the keys. Due to generics, this value can be of any form.

    • Next: Since the LinkedHashMap stores the insertion order, this contains the address to the next node of the LinkedHashMap.

    • Previous: This parameter contains the address to the previous node of the LinkedHashMap.

  • 3.The implementation of LinkedHashMap is not synchronized.

  • 4.It contains only unique elements.

  • 5.It may have one null key and multiple null values.

  • 6.It is the same as HashMap with an additional feature that it maintains insertion order. For example, when we run the code with a HashMap, we get a different order of elements.

  • That is, It first take elements according to their hash,

    Then if any insertion occurs it inserts them as (doubly)linked list.

    Constructors of LinkedHashMap

    • It is used to construct a default LinkedHashMap.
      
      Constructs an empty insertion-ordered LinkedHashMap instance ,
      with the default initial capacity (16) and load factor (0.75).
          
    • It is used to initialize a LinkedHashMap with the given capacity.
      
      Constructs an empty insertion-ordered LinkedHashMap instance ,
      with the specified initial capacity and a default load factor (0.75).
          
    • It is used to initialize both the capacity and the load factor.
      
      Constructs an empty insertion-ordered LinkedHashMap instance,
      with the specified initial capacity and load factor.
          
    • It is used to initialize both the capacity and the load factor with specified ordering mode.
      
      Constructs an empty LinkedHashMap instance ,
      with the specified initial capacity, load factor and ordering mode.
          
    • It is used to initialize the LinkedHashMap with the elements from the given Map class m.
      
      Constructs an insertion-ordered LinkedHashMap instance ,
      with the same mappings as the specified map. 
      The LinkedHashMap instance is created with a default load factor (0.75) 
      and an initial capacity sufficient to hold the mappings in the specified map.
          
      Constructor Description
      LinkedHashMap() It is used to construct a default LinkedHashMap. Constructs an empty insertion-ordered LinkedHashMap instance , with the default initial capacity (16) and load factor (0.75).
      LinkedHashMap(int capacity) It is used to initialize a LinkedHashMap with the given capacity.Constructs an empty insertion-ordered LinkedHashMap instance , with the specified initial capacity and a default load factor (0.75).
      LinkedHashMap(int capacity, float loadFactor) It is used to initialize both the capacity and the load factor.Constructs an empty insertion-ordered LinkedHashMap instance, with the specified initial capacity and load factor.
      LinkedHashMap(int capacity, float loadFactor, boolean accessOrder) It is used to initialize both the capacity and the load factor with specified ordering mode.Constructs an empty LinkedHashMap instance , with the specified initial capacity, load factor and ordering mode.
      LinkedHashMap(Map m) It is used to initialize the LinkedHashMap with the elements from the given Map class m.Constructs an insertion-ordered LinkedHashMap instance , with the same mappings as the specified map. The LinkedHashMap instance is created with a default load factor (0.75) and an initial capacity sufficient to hold the mappings in the specified map.

    Methods of LinkedHashMap

    • New Method :

      Methods Does This
      removeEldestEntry() It is used keep a track of whether the map removes any eldest entry from the map. So each time a new element is added to the LinkedHashMap, the eldest entry is removed from the map. This method is generally invoked after the addition of the elements into the map by the use of put() and putall() method.
    • It is used keep a track of whether the map removes any eldest entry from the map. 
      So each time a new element is added to the LinkedHashMap, the eldest entry is removed from the map. 
      This method is generally invoked after the addition of the elements into the map,
      by the use of put() and putall() method.
      
      Eg:
      
      If Map = {a=1, b=2, c=3, d=4, e=5, f=6, g=7, h=8, i=9, j=10}
      
      Then, removeEldestEntry :
      Size < 1 or Size ==0  → {a=1, b=2, c=3, d=4, e=5, f=6, g=7, h=8, i=9, j=10}
      Size > 1 = {j=10}
      Size > 2 = {i=9, j=10}
      Size > 3 = {h=8, i=9, j=10}
      ..... etc.

Synchronization of LinkedHashMap

  • 1.The implementation of LinkedHashMap is not synchronized.

  • 2.If multiple threads access a linked hash map concurrently, and at least one of the threads modifies the map structurally, it must be synchronized externally.This is typically accomplished by synchronizing on some object that naturally encapsulates the map.

  • 3. If no such object exists, the map should be “wrapped” using the Collections.synchronizedMap method . This is best done at creation time, to prevent accidental unsynchronized access to the map.

Identity Hash Map

    sequenceDiagram
        
      
      java.util.Map->>java.util.AbstractMap:implements 
      java.util.AbstractMap->>java.util.IdentityHashMap:extends
      java.io.Serializable->>java.util.IdentityHashMap:implements 
      java.lang.Cloneable->>java.util.IdentityHashMap:implements 
    
    Loading
  • 1. A IdentityHashMap is an extension of the AbstractMap class and it implements the Map interface.

  • 2. It is not synchronized and must be synchronized externally.

  • 3. It uses reference equality rather than using the equals() method. It uses the == operator.

  • 4. Iterators are fail-fast, throw ConcurrentModificationException in an attempt to modify while iterating.ConcurrentModificationException exception may be thrown by methods that have detected concurrent modification of an object when such modification is not permissible.

  • public class IdentityHashMap<K,​V> extends AbstractMap<K,​V> implements Map<K,​V> 
    ,Serializable, Cloneable 
    

    Constructors of IdentityHashMap

    • Constructs a new, empty identity hash map with a default expected maximum size (21).
          
    • It creates a new and empty identity hash map with the given specified expected maximum size.
      
      Constructs a new, empty map with the specified expected maximum size. 
      Putting more than the expected number of key-value mappings into the map ,
      may cause the internal data structure to grow, which may be somewhat time-consuming.
          
    • It creates a new identity hash map with the key-value pairs given in the specified map.
      
      Constructs a new identity hash map containing the keys-value mappings in the specified map.
          

      Constructor Does This
      IdentityHashMap() Constructs a new, empty identity hash map with a default expected maximum size (21).
      IdentityHashMap(int ExpectedMaxSize) It creates a new and empty identity hash map with the given specified expected maximum size. Constructs a new, empty map with the specified expected maximum size. Putting more than the expected number of key-value mappings into the map , may cause the internal data structure to grow, which may be somewhat time-consuming.
      IdentityHashMap(Map m) It creates a new identity hash map with the key-value pairs given in the specified map.

      Constructs a new identity hash map containing the keys-value mappings in the specified map.

    Methods of IdentityHashMap

    • 2. Difference between HashMap and Identity HashMap.

      • For Hash Map:
        
        map.put("a", 1);
        
        a is a String constant and 1 is Integer constant.
        
        map.put(new String("a"), 2);
        
        Here a is an object of String and 2 is an Integer constant.
        
        But in HashMap it check key as :
        
        map.put("a", 1).equals(map.put(new String("a"), 1));
        
        i.e., it treats constant and object is equal as Keys are same i.e. "a".
        
        i.e. "a".equals("a")
        
        Which returns true , where as:
        
        For Identity Hash Map:
        
        map1.put("a", 1).equals(map1.put(new String("a"), 1))
        
        Here it treats constant and object are different i.e.
        
        "a" not equal to {new String("a")}
        
        i.e. it uses:
        
        "a" == {new String("a")} which is false
        
        Hence it creates : {a=1,a=1} map
        
        
        Now in Identity Hash Map: 
        
         map1.put("a", 2); will update,
         1st Key which have String constant ,
         
         i.e. : {a=2,a=1}
         
        map1.put(new String("a"), 2); will update,
        2nd Key which have String object ,
        
         i.e. : {a=2,a=2}
         
         While for HashMap:
         map.put("a", 1);
         = {a=1}
         map.put(new String("a"),2}
         =  {a=2}
         map.put("a",3}
         =  {a=3}
         
         .... etc
         
         This is the differnce between Hash Map and Identity Map.

    Synchronized IdentityHashMap

      When more than one threads access the identity hash map concurrently, and at least one of the threads structurally modifies the map, it is necessary to synchronize that map externally. (Structural modification of map is to add or delete one or more key value mappings. If we just change the value associated with a key that an instance contains already is not structural modification.)

      It can be achieved by synchronizing on any object that encapsulate the map. If such object doesn't exist, map should be wrapped with the help of Collections.synchronizedMap() method. The correct time to do this is at the time of creation, in order to prevent unsynchronized access to map.

Weak Hash Map

    sequenceDiagram
        
      
      java.util.Map->>java.util.AbstractMap:implements 
      java.util.AbstractMap->>java.util.WeakHashMap:extends
      
      
    
    Loading

    public class WeakHashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>
    

  • 1. WeakHashMap is an implementation of the Map interface, that stores only weak references to its keys.

  • 2. Storing only weak references allows a key-value pair to be garbage-collected when its key is no longer referenced outside of the WeakHashMap.

  • 3. WeakHashMap does not implement Cloneable interface, hence it doesnot have clone() functionality.

  • 4. If object is specified as key doesn’t contain any references- it is eligible for Garbage Collection even though it is associated with WeakHashMap. i.e. Garbage Collector dominates over WeakHashMap.

  • 5. In WeakHashmap, When a key is discarded then its entry is automatically removed from the map, in other words, garbage collected.

  • WeakReference Vs Strong Reference[on Reference to Hash Map and Weak Map]

      1.Strong Reference:

      public class example {
          public static void main(String[] args) {
              example obj = new example();
              obj = null;
              System.gc();
          }
          
          
      }
      

      Here "obj" object has strong reference to the instance of class "example" .

      Hence Not eligible for garbage collection until:

      obj = null 
      

      i.e. The object is garbage collected only when the variable which was strongly referenced points to null.

      As 'obj' object is no longer referencing to the instance of class: "example".

      Best example:

      class ex{
          public void finalize(){
              System.out.println("Finalize method called");
          }
      }
      public class example {
          public static void main(String[] args) {
              ex obj = new ex();
              obj.finalize();
              obj = null;
              System.gc();//Garbage Collector
              obj.finalize();//will not call finalize method and throws Null Pointer Exception
          }
          
          
      }
      

      In HashMap, key objects have strong references.

    2.Weak Reference:

    • 1. This type of reference is used in WeakHashMap to reference the entry objects .

    • 2. If JVM detects an object with only weak references (i.e. no strong or soft references linked to any object), this object will be marked for garbage collection.

    • 3. To create such references java.lang.ref.WeakReference class is used.

    • 4. Weak Reference Objects are not the default type/class of Reference Object. They are explicitly specified while using them.

    • import java.lang.ref.WeakReference;
      
      class exceptions {
          void print() {
              System.out.println("Print method called");
          }
      }
      
      public class WeakRefexample {
          public static void main(String[] args) {
      
              // Strong Reference
              exceptions obj = new exceptions();
              obj.print();
      
              // Weak Reference has explicit type class[exceptions] of Reference Object[obj]
              WeakReference<exceptions> weak = new WeakReference<>(obj); 
      
              obj = null;
              exceptions obj1 = weak.get();
      
              /**
               * 
               * get() function : It returns this reference object's referent.
               * If this reference object has been cleared,
               * either by the program or by the garbage collector,
               * then this method returns null.
               * 
               **/
      
              obj1.print(); // will call print method and will not throw any exceptions
          }
      
      }
      

    Constructors of WeakHashMap

    • It is used to construct a default constructor of WeakHashMap.
      
      This constructor constructs a new, 
      empty WeakHashMap with the default initial capacity (16) 
      and the default load factor (0.75).
          
    • This constructor constructs a new, 
      empty WeakHashMap with the given 
      initial capacity and 
      the default load factor, which is 0.75.
          
    • This constructor constructs a new, empty WeakHashMap 
      with the given initial capacity and the given load factor.
          
    • This constructor constructs a new WeakHashMap ,
      with the same mappings as the specified Map.
          
      Constructor Does This
      WeakHashMap() It is used to construct a default constructor of WeakHashMap.This constructor constructs a new, empty WeakHashMap with the default initial capacity (16) and the default load factor (0.75).
      WeakHashMap(int initialCapacity) This constructor constructs a new, empty WeakHashMap with the given initial capacity and the default load factor, which is 0.75.
      WeakHashMap(int initialCapacity, float loadFactor) This constructor constructs a new, empty WeakHashMap with the given initial capacity and the given load factor.
      WeakHashMap(Map m) This constructor constructs a new WeakHashMap , with the same mappings as the specified Map.

    Methods of WeakHashMap

    • Consider a Class:
      
      class demo{
          @Override
          public String toString() {
              return "demo";
          }
          public void finalize(){
              System.out.println("Finalize method called");
          }
      
      }
      
      Now:
      
      class weakhashmap2{
       public static void main(String[] args){
        WeakHashMap<Object, Integer> map = new WeakHashMap<>();
        demo d = new demo();
        map.put(d, 1);
         
         Now:
         
         : Object is assigned to null :
         
         d = null;
         
         : And , Grabage Collector is called :
         
          System.gc();
          
          : Which will empty the Map as it is a Weak Reference :
          : As, Weak Reference is cleared by gc :
          
          Next:
          We input Key as d and an integer 1 in the map:
          map.put(d, 1);
          we know d has already assigned to null hence the output: Map:{null=1}
          
          Now we create another object say :
          demo d2 = new demo();
          map.put(d2, 2);
          
          So output will be: Map:{null=1,  demo=2}
          
          : Hence it signifies the WeakReference of Key, Value pair in Weak HashMap. :
          
          : But in Hash Map : 
          
          HashMap<Object, Integer> m = new HashMap<>();
          demo d1 = new demo();
          m.put(d1, 1);
          
          :Output: Map = {demo=1}
          
          d1 = null;//Object is referenced to null.
          System.gc();//garbage collector is called.
          
          :And again if map is called:
          :It will put Object → d1 and Integer→ 1 : 
          :As HashMap is strongly referenced to Object → d1 and Integer→ 1:
          
          System.out.println( m);
          
          :Output →  {demo=1}:
          
           Now we create another object say :
           demo d3 = new demo();
           m.put(d3, 2);
           System.out.println( m);
            
           :Output: Map = {demo=1, demo=2}
           
           :Note → d1,d2,d3 are different Objects of demo class :
           :And are reffered to here as different keys : 
           :For both HashMap and WeakHashMap : 
           
           
        }
      }
         
      

B.Sorted Map - Interface

sequenceDiagram

  java.util.SortedMap->>java.util.Map:extends
  
Loading

public interface SortedMap<K, V> extends Map<K, V>

  • SortedMap is an interface in the collection framework.

  • This interface extends the Map interface and provides a total ordering of its elements , (elements can be traversed in sorted order of keys).

  • The class that implements this interface is TreeMap.

  • Methods of Sorted Map - Interface

    • 1.Comparator() - Example

    • Returns the first (lowest) key currently in this map.
      
    • Returns the last (highest) key currently in this map.
      
    • headMap(toKey:Key) : 
      Returns a view of the portion of this map whose keys are strictly less than toKey.
      
    • tailMap(fromKey:Key) : 
      Returns a view of the portion of this map whose keys are greater than and equal to fromKey.
      
    • Returns a view of the portion of this map whose keys range from fromKey, inclusive, 
      i.e. including fromKey and to toKey, exclusive i.e. excluding toKey.
      
      Methods Does This
      1.Comparator()

      A comparison function, which imposes a total ordering on some collection of objects. Comparators can also be used to control the order of sorted maps . Here,It returns the comparator used to order the keys in this map, or null if this map uses the natural ordering of its keys.

      2.FirstKey()

      Returns the first (lowest) key currently in this map.

      3.LastKey()

      Returns the last (highest) key currently in this map.

      4.HeadMap(toKey:Key)

      Returns a view of the portion of this map whose keys are strictly less than toKey.

      5.TailMap(fromKey:Key)

      Returns a view of the portion of this map whose keys are greater than and equal to fromKey.

      6.SubMap(fromKey:Key, toKey:Key)

      Returns a view of the portion of this map whose keys range from fromKey, inclusive, i.e. including fromKey and to toKey, exclusive i.e. excluding toKey.

      Note: SortedMap interface extends Map interface , hence it also inherits all functions from Map interface.

C.Navigable Map - Interface

sequenceDiagram

  java.util.NavigableMap->>java.util.SortedMap:extends 
  java.util.SortedMap->>java.util.Map:extends
  
Loading

public interface NavigableMap<K,V> extends SortedMap<K,V>

public interface SortedMap<K, V> extends Map<K, V>

  • The NavigableMap interface is a member of the Java Collection Framework.

  • A NavigableMap can be easily accessed and traversed in either ascending or descending key order.

  • It belongs to java.util package and It is an extension of SortedMap which provides convenient navigation methods.

  • As it extends Sorted Map , hence methods of all Sorted Map interface can be accessed by Navigable Map .

  • These Navigation Methods are discussed below.

  • Methods of Navigable Map

    • Returns a key-value mapping associated with the least key greater than 
      or equal to the given key, or null if there is no such key.
      
    • Returns the least key greater than or equal to the given key, 
      or null if there is no such key.
      
    • Returns a reverse order NavigableSet view of the keys contained in this map.
      The set's iterator returns the keys in descending order. 
      The set is backed by the map, so changes to the map are reflected in the set, and vice-versa. 
      If the map is modified while an iteration over the set is in progress 
      (except through the iterator's own remove operation), the results of the iteration are undefined. 
      The set supports element removal, which removes the corresponding mapping from the map, 
      via the Iterator.remove, Set.remove, removeAll, retainAll, and clear operations. 
      
      :It does not support the add or addAll operations:
      
    • Returns a reverse order view of the mappings contained in this map. 
      
    • Returns a key-value mapping associated with the least key in this map, 
      or null if the map is empty.
      
    • Returns a key-value mapping associated with the greatest key less than 
      or equal to the given key, or null if there is no such key.
      
    • Returns the greatest key less than or equal to the given key,
      or null if there is no such key.
      
    • Returns a view of the portion of this map whose keys are less than 
      (or equal to, if inclusive is true) toKey.
      
      if true:
      Returns a view of the portion of this map whose keys are equal to toKey,if inclusive is true.
      
      if false:
      Returns a view of the portion of this map whose keys are less than toKey,if inclusive is false.
      
    • Returns a key-value mapping associated with the least key strictly greater than the given key,
      or null if there is no such key.
      
    • Returns the least key strictly greater than the given key, or null if there is no such key.
      
    • Returns a key-value mapping associated with the greatest key in this map, 
      or null if the map is empty.
      
    • Returns a key-value mapping associated with the greatest key strictly less than the given key, 
      or null if there is no such key.
      
    • Returns the greatest key strictly less than the given key, or null if there is no such key.
      
    • Returns a NavigableSet view of the keys contained in this map. 
      The set's iterator returns the keys in ascending order. 
      The set is backed by the map, so changes to the map are reflected in the set, and vice-versa. 
      The set supports element removal, which removes the corresponding mapping from the map, 
      via the Iterator.remove, Set.remove, removeAll, retainAll, and clear operations. 
      
      
      :It does not support the add or addAll operations:
      
    • Removes and returns a key-value mapping associated with the least key in this map, 
      or null if the map is empty.
      
    • Removes and returns a key-value mapping associated with the greatest key in this map, 
      or null if the map is empty.
      
    • Returns a view of the portion of this map whose keys range from fromKey to toKey. 
      If fromKey and toKey are equal, the returned map is empty 
      unless fromInclusive and toInclusive are both true.
      
    • Returns a view of the portion of this map whose keys are greater than, 
      (or equal to, if inclusive is true) fromKey.
      
      Methods Does This
      1.ceilingEntry Returns a key-value mapping associated with the least key greater than or equal to the given key, or null if there is no such key.
      2.ceilingKey Returns the least key greater than or equal to the given key, or null if there is no such key.
      3.descendingKeySet

      Returns a reverse order NavigableSet view of the keys contained in this map. The set's iterator returns the keys in descending order. The set is backed by the map, so changes to the map are reflected in the set, and vice-versa. If the map is modified while an iteration over the set is in progress (except through the iterator's own remove operation), the results of the iteration are undefined. The set supports element removal, which removes the corresponding mapping from the map, via the Iterator.remove, Set.remove, removeAll, retainAll, and clear operations. It does not support the add or addAll operations.

      4.descendingMap Returns a reverse order view of the mappings contained in this map.
      5.firstEntry Returns a key-value mapping associated with the least key in this map, or null if the map is empty.
      6.floorEntry Returns a key-value mapping associated with the greatest key less than or equal to the given key, or null if there is no such key.
      7.floorKey Returns the greatest key less than or equal to the given key, or null if there is no such key.
      8.headMap(K toKey, boolean inclusive) Returns a view of the portion of this map whose keys are less than (or equal to, if inclusive is true) toKey.

      if true: Returns a view of the portion of this map whose keys are equal to toKey,if inclusive is true.

      if false: Returns a view of the portion of this map whose keys are less than toKey,if inclusive is false.

      9.higherEntry Returns a key-value mapping associated with the least key strictly greater than the given key, or null if there is no such key.
      10.higherKey Returns the least key strictly greater than the given key, or null if there is no such key.
      11.lastEntry Returns a key-value mapping associated with the greatest key in this map, or null if the map is empty.
      12.lowerEntry Returns a key-value mapping associated with the greatest key strictly less than the given key, or null if there is no such key.
      13.lowerKey Returns the greatest key strictly less than the given key, or null if there is no such key.
      14.navigableKeySet Returns a NavigableSet view of the keys contained in this map. The set's iterator returns the keys in ascending order. The set is backed by the map, so changes to the map are reflected in the set, and vice-versa. The set supports element removal, which removes the corresponding mapping from the map, via the Iterator.remove, Set.remove, removeAll, retainAll, and clear operations. It does not support the add or addAll operations.
      15.pollFirstEntry Removes and returns a key-value mapping associated with the least key in this map, or null if the map is empty.
      16.pollLastEntry Removes and returns a key-value mapping associated with the greatest key in this map, or null if the map is empty.
      17.SubMap( fromKey:Key, boolean fromInclusive:true/false, toKey:Key, boolean toInclusive:true/false) Returns a view of the portion of this map whose keys range from fromKey to toKey. If fromKey and toKey are equal, the returned map is empty unless fromInclusive and toInclusive are both true.
      18.tailMap(fromKey :Key, boolean inclusive: true/false) Returns a view of the portion of this map whose keys are greater than, (or equal to, if inclusive is true) fromKey.

Tree Map

    sequenceDiagram
        
      
      java.util.Map->>java.util.AbstractMap:implements 
      java.util.AbstractMap->>java.util.TreeMap:extends
      java.util.Map->>java.util.SortedMap:extends
      java.util.SortedMap->>java.util.NavigableMap:extends
      java.util.NavigableMap->>java.util.TreeMap:implements
      java.io.Serializable->>java.util.TreeMap:implements 
      java.lang.Cloneable->>java.util.TreeMap:implements 
    
    Loading

    public class TreeMap<K,V> extends AbstractMap<K,V>
                              implements NavigableMap<K,V>,Cloneable,Serializable
    
    public interface NavigableMap<K,V> extends SortedMap<K,V>
    
    public interface SortedMap<K,V> extends Map<K,V>
    

  • 1. The TreeMap in Java is used to implement Map interface .

  • 2. The TreeMap in Java is used to implement NavigableMap interface .

  • 3. The TreeMap in Java is used to extend the abstract class : "AbstractMap" .

  • 4.TreeMap in Java does not allow null keys (like Map) and thus a NullPointerException is thrown.

  • 5.Multiple null values can be associated with different keys in Tree Map.

  • 6.TreeMap contains only unique elements.

  • 7.TreeMap is non synchronized.

  • 8.TreeMap maintains ascending order. As Tree Map implements " Navigable Map" and Navigable Map extends Sorted Map. Hence tree map maintains sorted structure of map i.e. in ascending order.

  • 9." Entry pairs " returned by the methods in this class and its views represent snapshots of mappings at the time they were produced. " Entry.SetValue " is only supported when we try to change every specific values of the keys through a loop , But do not support the " Entry.setValue " method for individual entries.And they throw "Unsupported Operation Exception" .

  • 10.TreeMap is based upon a red-black tree data structure.( Red Black Trees are self-balancing, meaning that the tree adjusts itself automatically after each insertion or deletion operation. )

  • Constructors of TreeMap

    • It is used to construct a default constructor of TreeMap.
      
      It is used to construct an empty tree map,
      that will be sorted using the natural order of its key.
          

      2. TreeMap(Comparator comparator)

      It is used to construct an empty tree-based map,
      that will be sorted using the comparator. 
          
      • Acc. to above eg:
        
        TreeMap2(no:1, name:"one", value:1)
        
        o1 and o2 are two object of TreeMap2,
        
        Therefore Comparison:
        
        o1.value - o2.value,
        i.e,1st Diff: 1-1 = 0
        
        TreeMap2(no:2, name:"two", value:2)
        
        Therefore Comparison:
        
        2nd Difference: 2-1 = 1
        
        TreeMap2(no:3, name:"three", value:3)
        
        o1.value: 3 - o2.value: 1 = 2
        
        o1.value: 3 - o2.value: 2 = 1
        
        TreeMap2(no:4, name:"four", value:4)
        
        o1.value: 4 - o2.value: 2 = 2
        
        o1.value: 4 - o2.value: 3 = 1
        
        Similary:
        TreeMap2(no:5, name:"five", value:5)
        
        o1.value: 5 - o2.value: 2 = 3
        
        o1.value: 5 - o2.value: 3 = 2
        
        o1.value: 5 - o2.value: 4 = 1
        
        
        ....etc.
        
        Hence:
        
        if we see the comparison:
        
        0 1 2 3 4 5 in ascending order.
        
        Hence Result is in  ascending order.
        
      • Acc. to above eg:
        
        TreeMap2(no:1, name:"one", value:1)
        
        o1 and o2 are two object of TreeMap2,
        
        Therefore Comparison:
        
        o2.value - o1.value,
        i.e,1st Diff: 1-1 = 0
        
        TreeMap2(no:2, name:"two", value:2)
        
        Therefore Comparison:
        
        2nd Difference: 1-2 = -1
        
        TreeMap2(no:3, name:"three", value:3)
        
        o2.value: 1 - o1.value: 3 = -2
        
        o2.value: 2 - o1.value: 1 = -1
        
        TreeMap2(no:4, name:"four", value:4)
        
        o2.value: 2 - o1.value: 4 = -2
        
        o2.value: 3 - o1.value: 4 = -1
        
        Similary:
        TreeMap2(no:5, name:"five", value:5)
        
        o2.value: 2 - o2.value: 5 = -3
        
        o2.value: 3 - o2.value: 5 = -2
        
        o2.value: 4 - o2.value: 5 = -1
        
        
        ....etc.
        
        Hence:
        
        if we see the comparison:
        
        -5 -4 -3 -2 -1 0 in descending order.
        
        Hence Result is in descending order.
        
    • It is used to initialize a treemap with the entries from object of Map, 
      which will be sorted using the natural order of the keys.
      
    • It is used to initialize a treemap with the entries from object of SortedMap, 
      which will be sorted using the natural order of the keys.
      
    • It is used to initialize a treemap with the entries from object of NavigableMap, 
      which will be sorted using the natural order of the keys.
      
      Note :  NavigableMap extends SortedMap
      And : TreeMap implements NavigableMap
      
      Constructor Does This
      1.TreeMap()

      It is used to construct a default constructor of TreeMap.

      It is used to construct an empty tree map, that will be sorted using the natural order of its key.

      2.TreeMap(Comparator comparator)

      It is used to construct an empty tree-based map, that will be sorted using the comparator.

      3.TreeMap(Map m)

      It is used to initialize a treemap with the entries from object of Map, which will be sorted using the natural order of the keys.

      4.TreeMap(SortedMap m)

      It is used to initialize a treemap with the entries from object of SortedMap, which will be sorted using the natural order of the keys.

      5.TreeMap(NavigableMap m)

      It is used to initialize a treemap with the entries from object of NavigableMap, which will be sorted using the natural order of the keys.

      Note : NavigableMap extends SortedMap, And : TreeMap implements NavigableMap.

    Methods of TreeMap

    • Note: These methods are already part of WeakHashMap , IdentityHashMap and HashMap .

    • Note: These methods are already part of Sorted Map Interface Methods, as TreeMap implements NavigableMap and NavigableMap extends SortedMap .

    • Suppose we have descendingKeySet() or navigableKeySet() functions:
      
      Then:
      
      The Set that will be produced by those function can be reserved in Set variable/object.
      
      1. Set<Type> set_var = TreeMap.navigableKeySet();
      
      2. Set<Type> set_var = TreeMap.descendingKeySet();
      
      Similary for Entry say, lastEntry() or pollFirstEntry():
      
      Then: 
      
      It calls for Maps.Entry and reserves such entries under its variable/object.
      
      i.e. 
      Import java.util.Map.Entry;
      Entry<Type1, Type2> entry_var = TreeMap.pollLastEntry();
      
      or:
      Map.Entry <Type1, Type2> entry_var = TreeMap.pollLastEntry();
      
      Similary for tailMap() or subMap() type Functions:
      
      They are always stored under the Map object/variable.
      
      i.e.
      
       Map<Type1, Type2> map_var = TreeMap.tailMap(fromKey:Key, inclusive: true/false);
       
       If we want to store any key object then it can be store under it's type varibale:
       
       Eg:
       TreeMap<Float, String> treeMap = new TreeMap<>();
       Float float_var = treeMap.lowerKey(4.0f);
      

      Note: These methods are already part of Navigable Map Interface Methods, as TreeMap implements NavigableMap .

Synchronization of TreeMap

    The implementation of a TreeMap is not synchronized. This means that if multiple threads access a tree set concurrently, and at least one of the threads modifies the set, it must be synchronized externally. This is typically accomplished by using the Collections.synchronizedSortedMap method. Also it can be locked by synchronized() method and all such map objects can execute synchronized in a single thread.

Enum Map

sequenceDiagram

  java.util.EnumMap->>java.util.AbstractMap:extends 
  java.util.EnumMap->>java.io.Serializable:implements
  java.util.EnumMap->>java.io.Cloneable:implements
  java.util.AbstractMap->>java.util.Map:implements
  java.util.AbstractMap->>java.lang.Object:extends

Loading

public class EnumMap<K extends Enum<K>,​V> 
                    extends AbstractMap<K,​V> 
                    implements Serializable, Cloneable

public abstract class AbstractMap<K,V> extends Object, implements Map<K,V>

  • 1. EnumMap class is a member of the Java Collections Framework .

  • 2. EnumMap extends AbstractMap and AbstractMap (abstract class) implement Map Interface.

  • 3. EnumMap doesn’t allow null key and throws NullPointerException .

  • 4. All keys of each EnumMap instance must be keys of a single enum(enumeration) type.

  • 5.It’s a high-performance map implementation, much faster than HashMap.

  • 6.Iterators returned by the collection views are weakly consistent: they will never throw ConcurrentModificationException and they may or may not show the effects of any modifications to the map that occur while the iteration is in progress.

  • 7.EnumMap is internally represented as arrays. This representation is extremely compact and efficient.

  • Constructors of EnumMap

    • Creates an empty enum map with the specified key type.
      
    • Creates an enum map with the same key type as the specified enum map,
      initially containing the same mappings (if any).
      
    • It is used to create an enum map initialized from the specified map.
      
      Constructor Does This
      1 . EnumMap(Class keyType) Creates an empty enum map with the specified key type.
      2 . EnumMap(EnumMap m) Creates an enum map with the same key type as the specified enum map, initially containing the same mappings (if any).
      3 . EnumMap(Map m) It is used to create an enum map initialized from the specified map.

    Methods of EnumMap

    • Note : 
      
      Map.values() returns a Collection , 
      Hence the return value can be stored in object/variable of Collection.
      
      import java.util.Collection;
      Collection<Type> col_var =Map.values() ;
      

      Note: These methods are already discussed earlier.

D.ConcurrentMap -Interface

sequenceDiagram

  java.util.concurrent.ConcurrentMap->>java.util.Map:extends 
  
Loading

public interface ConcurrentMap<K,V> extends Map<K,V>

  • 1. ConcurrentMap is an interface and it is a member of the Java Collections Framework .

  • 2. ConcurrentMap is introduced in JDK 1.5 .

  • 3. ConcurrentMap represents a Map that is capable of handling concurrent access to the Map,without affecting the consistency of entries in a map .

  • 4. ConcurrentMap interface present in java.util.concurrent package .

  • 5. ConcurrentMap extends the Map interface in Java.

  • 6. ConcurrentMap is known as a synchronized Map.

  • 7. ConcurrentMap is implemented by ConcurrentSkipListMap and ConcurrentHashMap classes.

  • Methods of ConcurrentMap Interface

    • Note:
      
      For having all the entries of a Map as a Set:
      
      We have entrySet() function:
      
      It can be stored in Set's variable /object by:
      
      Either:
      
      Set<Map.Entry<keyType, valueType>> set_var = Map.entrySet();
      
      Or:
      
      import java.util.Map.Entry;
      
      Set<Entry<keyType, valueType>> set_var = Map.entrySet();
      
      

      Note: These methods are already discussed earlier.

    New Methods Of ConcurrentMap

    • Returns an unmodifiable map containing zero mappings.
      
    • Returns an unmodifiable map containing 'N'mappings.
      
    • Returns an unmodifiable map containing keys and values,
      extracted from the given entries. 
      The entries themselves are not stored in the map.
      
      New Methods Does This
      1.Application of of() Method Returns an unmodifiable map containing zero mappings.
      2.Application of of(1K,1V,..,nK,nV) Method Returns an unmodifiable map containing 'N'mappings.
      3.Application of of(Map.Entry… entries) Method Returns an unmodifiable map containing keys and values, extracted from the given entries. The entries themselves are not stored in the map.

E.ConcurrentNavigableMap Interface

sequenceDiagram

  java.util.concurrent.ConcurrentNavigableMap->>java.util.ConcurrentMap:extends
  java.util.concurrent.ConcurrentNavigableMap->>java.util.NavigableMap:extends
  java.util.concurrent.ConcurrentMap->>java.util.Map:extends 
  java.util.NavigableMap->>java.util.SortedMap:extends 
  java.util.SortedMap->>java.util.Map:extends
  
Loading

public interface ConcurrentNavigableMap<K,V> extends ConcurrentMap<K,V>
                                                 , NavigableMap<K,V>
                                                 
public interface ConcurrentMap<K,V> extends Map<K,V>
public interface NavigableMap<K,V> extends SortedMap<K,V>
public interface SortedMap<K, V> extends Map<K, V>

  • 1. The ConcurrentNavigableMap interface is a member of the Java Collection Framework .

  • 2. ConcurrentNavigableMap extends from the NavigableMap interface and ConcurrentMap interface .

  • 3. The ConcurrentNavigableMap provides thread-safe access to map elements along with providing convenient navigation methods .

  • 4. ConcurrentNavigableMap belongs to java.util.concurrent package.

  • 5. ConcurrentNavigableMap is SubInterface of ConcurrentMap interface .

  • 6. ConcurrentNavigableMap is also Synchronized , like ConcurrentMap interface .

  • 7. ConcurrentNavigableMap is implemented by ConcurrentSkipListMap class.

  • Methods of ConcurrentNavigableMap

    Note: The methods of ConcurrentNavigableMap Interface are inherited from SortedMap interface,,Map Interface,NavigableMap Interface and ConcurrentMap Interface.Hence some of them are discussed above.

ConcurrentHashMap

sequenceDiagram

  java.util.concurrent.ConcurrentHashMap->>java.util.AbstractMap:extends 
  java.util.concurrent.ConcurrentHashMap->>java.util.concurrent.ConcurrentMap:implements
  java.util.concurrent.ConcurrentHashMap->>java.io.Serializable:implements
  java.util.concurrent.ConcurrentMap->>java.util.Map:extends 
  java.util.AbstractMap->>java.util.Map:implements
  java.util.AbstractMap->>java.lang.Object:extends

Loading

public class ConcurrentHashMap<K,​V> extends AbstractMap<K,​V> 
                                    implements ConcurrentMap<K,​V>, Serializable
                               
public interface ConcurrentMap<K,V> extends Map<K,V>

public abstract class AbstractMap<K,V> extends Object implements Map<K,V>

  • 1.The ConcurrentHashMap class is introduced in JDK 1.5 .

  • 2.The ConcurrentHashMap belongs to java.util.concurrent package.

  • 3.The ConcurrentHashMap class is thread-safe i.e. multiple threads can operate on a single object without any complications i.e Synchronization .

  • 4.Hashtable is thread safe but give poor performance in multi-threading.Hashmap can solve performance issue by giving parallel access to multiple threads reading hashmap simultaneously but Hashmap is not thread safe, hence ConcurrentHashMap is introduced in JDK 1.5. ConcurrentHashMap is thread safe ,it creates an array and each index of this array represents a HashMap. And Hashtable and HashMap both uses array and linkedlist as the data structure to store the data. Hence ,we can say, the underlined data structure for ConcurrentHashMap is Hashtable.

  • 5.The default concurrency-level of ConcurrentHashMap is 16.

  • 6.In ConcurrentHashMap, the Object is divided into a number of segments according to the concurrency level.

  • 7.In ConcurrentHashMap, at a time any number of threads can perform retrieval operation.

  • 8.In ConcurrentHashMap, to have a update in the object, the thread must lock the particular segment in which the thread wants to operate. This type of locking mechanism is known as Segment locking or bucket locking. Hence at a time, 16 update operations can be performed by threads as default concurrency-level of ConcurrentHashMap is 16.

  • 9.In ConcurrentHashMap, the higher the concurrency level, the more threads can access its buckets at once.

  • 10.In ConcurrentHashMap class is designed for use in concurrent data access,i.e. accessing data at same time.

  • 11.Inserting null objects is not possible in ConcurrentHashMap as a key or value.

  • 12.The ConcurrentHashMap doesn’t throw a ConcurrentModificationException if one thread tries to modify it while another is iterating over it.

  • ConcurrentHashMap

    1_N2ZCdgWnzlrWXczTvfvPFQ

    In More Details

    1_U3oE8gg95rTulEJQGG10GQ

    Note : Concurrent HashMap introduced parallelism threshold parameter, which says: "How many elements are needed for an operation to be executed in parallel, synchronized".

    Size of Segment Calculation

    Concurrency-Level: It is the number of threads concurrently updating the map.

    Segment in ConcurrentHashMap : In ConcurrentHashMap, the Object is divided into a number of segments according to the concurrency level.Each Segment has an Array of HashMap.

    [Segment Size = 2^x >=(initialCapacity / concurrencyLevel)]

    If concurrency level = 10

    Segment Size = 2^x >= 10

    if x= 3 then 2^3 >= 10 = 8>=10 (Wrong)

    Then,

    x= 4 then 2^4 >= 10 = 16>=10 (Right)

    Hence Segment Size = 16

    Constructors of ConcurrentHashMap

    • Creates a new, empty map with a default initial capacity (16), 
      load factor (0.75) and concurrencyLevel (16)
      
      Initial Capacity: Number of elements initially that a map can have. 
      if the capacity of this map is 10. It means that it can store 10 entries.
      
      LoadFactor : 
      The load factor is the measure that decides when to increase the capacity of the Map.
      It’s a threshold, used to control resizing of the Map.
      
      Concurrency-Level: It is the number of threads concurrently updating the map.
      The implementation performs internal sizing to try to accommodate this many threads.
      
    • Creates a new, empty map with an initial table size,
      accommodating the specified number of elements,
      without the need to dynamically resize.
      
      That is: Creates a new, 
      empty map with the specified initial capacity, 
      and with default load factor (0.75) and concurrencyLevel (16)
      
    • Creates a new empty map ,
      with an initial table size based on the given number of elements (initialCapacity) 
      and initial table density (loadFactor).
      
      That is: Creates a new empty map ,
      with the specified initial capacity and 
      load factor and with the default concurrencyLevel (16).
      
    • Creates a new, empty map with an initial table size,
      based on the given number of elements (initialCapacity), 
      table density (loadFactor), a
      nd number of concurrently updating threads (concurrencyLevel).
      
      That is: Creates a new, empty map 
      with the specified initial capacity, 
      load factor, and concurrency level
      
    • Creates a new map with the same mappings as the given map.
      

    Methods of ConcurrentHashMap

    • Note: Here methods discussed are inherited from ConcurrentMap,AbstractMap,Map interfaces.

      Note: Clone() method is not implemented by ConcurrentHashMap.
      It belongs to Abstract Map which is not visible to the class.
      If called then it throws exception : CloneNotSupportedException.
      There is a reason why Clone() method not implemented in ConcurrentHashMap.
      The reason is : ConcurrentHashMap is Thread Safe and 
      creating a deep copy of the map would be difficult to implement .
      

      How to implement Clone method?

      New Methods of ConcurrentHashMap

      • Performs the given action for each non-null transformation of each (key, value).
        
        The parallelismThreshold : 
        It sets the number of items at which operations in a map begin to run concurrently.
        It determines whether bulk operations would be executed sequentially or in parallel.
        
        BiFunction: Represents a function that accepts two arguments and produces a result.
        
        Transformer: The transformer transforms the data before sending it to the Consumer.
        
        Consumer: It represents a functional interface which accepts 
        a single input argument and produces no result.
        
      • Performs the given action for each (key, value).
        
        The parallelismThreshold : 
        It sets the number of items at which operations in a map begin to run concurrently.
        It determines whether bulk operations would be executed sequentially or in parallel.
        
        BiFunction: Represents a function that accepts two arguments and produces a result.
        
      • Performs the given action for each (key, value).
        
        The parallelismThreshold : 
        It sets the number of items at which operations in a map begin to run concurrently.
        It determines whether bulk operations would be executed sequentially or in parallel.
        
        Consumer: It represents a functional interface which accepts 
        a single input argument and produces no result.
        
        
        
      • Performs the given action for each non-null transformation of each entry.
        
        The parallelismThreshold : 
        It sets the number of items at which operations in a map begin to run concurrently.
        It determines whether bulk operations would be executed sequentially or in parallel.
        
        Function: It takes one argument and produces a result.
        
        Transformer: The transformer transforms the data before sending it to the Consumer.
        
        Consumer: It represents a functional interface which accepts 
        a single input argument and produces no result.
        
      • Performs the given action for each non-null transformation of each entry.
        
        The parallelismThreshold : 
        It sets the number of items at which operations in a map begin to run concurrently.
        It determines whether bulk operations would be executed sequentially or in parallel.
        
        Consumer: It represents a functional interface which accepts 
        a single input argument and produces no result.
        
      • Performs the given action for each non-null transformation of each key.
        
        The parallelismThreshold : 
        It sets the number of items at which operations in a map begin to run concurrently.
        It determines whether bulk operations would be executed sequentially or in parallel.
        
        Function: It takes one argument and produces a result.
        
        Transformer: The transformer transforms the data before sending it to the Consumer.
        
        Consumer: It represents a functional interface which accepts 
        a single input argument and produces no result.
        
      • Performs the given action for each value.
        
        The parallelismThreshold : 
        It sets the number of items at which operations in a map begin to run concurrently.
        It determines whether bulk operations would be executed sequentially or in parallel.
        
        Consumer: It represents a functional interface which accepts 
        a single input argument and produces no result.
        
      • Performs the given action for each non-null transformation of each value.
        
        The parallelismThreshold : 
        It sets the number of items at which operations in a map begin to run concurrently.
        It determines whether bulk operations would be executed sequentially or in parallel.
        
        Function: It takes one argument and produces a result.
        
        Transformer: The transformer transforms the data before sending it to the Consumer.
        
        Consumer: It represents a functional interface which accepts 
        a single input argument and produces no result.
        
      • Returns a Set view of the keys in this map, 
        using the given common mapped value for any additions 
        (i.e., Collection.add and Collection.addAll(Collection)). 
        This is of course only appropriate if it is acceptable ,
        to use the same value for all additions from this view.
        
        Which means if a Set's object is set to Map's keyset with 
        its Mapped Value and if we continue to add with
        Collection.add () function through set the , added
        values will be refered as "Keys" of the map , automatically
        gets added to Map as "Keys" gets mapped with the given Value.
        
        Suppose we create an empty ConcurrentHashMap:
        
        ConcurrentHashMap<String, String> map = new ConcurrentHashMap<>();
        
        Set<String> set = map.keySet("1");
        set.add("one");
        System.out.println("Map:" + map);
        
        Output:
        
        Map:{one=1}
        
        Similarly,
        
        set = map.keySet("2");
        set.add("two");
        
        System.out.println("Map:" + map);
        
        Output:
        
        Map:{one=1, two=2}
        
        ....ETC.
        
        Same for set.addAll() Functionality ,but here ,
        
        Different keys will be assigned to Same Values.
        
        Set<String> set2 =new HashSet<>();
        set2.add("three");
        set2.add("four");
        set.addAll(set2);
        System.out.println("Map:" + map);
        
        Output:
        
        Map:{one=1, two=2, three=2, four=2}
        
        As last mapped value was 2.
         
         
        
        
      • Returns the number of mappings. 
        
        This method should be used instead of size . The reason is, 
        a ConcurrentHashMap may contain more mappings,
        than can be represented as an int. 
        The value returned is an estimate; 
        the actual count may differ ,
        if there are concurrent insertions or removals.
        
      • Creates a new Set backed by a ConcurrentHashMap,
        from the given type to Boolean.TRUE.
        
      • Creates a new Set backed by a ConcurrentHashMap,
        from the given type to Boolean.TRUE.
        
      • Returns the result of accumulating the given transformation ,
        of all (key, value) pairs using the given reducer ,
        to combine values, or null if none.
        
        :Description of the Code is inside:
        
      • Returns the result of accumulating all entries ,
        using the given reducer to combine values, or null if none.
        
      • Returns the result of accumulating the given transformation,
        of all entries using the given reducer to combine values, 
        or null if none.
        
      • Returns the result of accumulating the given transformation ,
        of all entries using the given reducer to combine values, 
        and the given basis as an identity value.
        
      • Returns the result of accumulating the given transformation ,
        of all entries using the given reducer to combine values, 
        and the given basis as an identity value.
        
      • Returns the result of accumulating the given transformation,
        of all entries using the given reducer to combine values, 
        and the given basis as an identity value.
        
      • Returns the result of accumulating all keys ,
        using the given reducer to combine values, 
        or null if none.
        
      • Returns the result of accumulating the given transformation,
        of all keys using the given reducer to combine values, 
        or null if none.
        
      • Returns the result of accumulating the given transformation,
         of all keys using the given reducer to combine values, 
        and the given basis as an identity value.
        
      • Returns the result of accumulating the given transformation,
        of all keys using the given reducer to combine values, 
        and the given basis as an identity value.
        
      • Returns the result of accumulating the given transformation,
        of all keys using the given reducer to combine values, 
        and the given basis as an identity value.
        
      • Returns the result of accumulating the given transformation of all
        (key, value) pairs using the given reducer to combine values,
        and the given basis as an identity value.
        
      • Returns the result of accumulating the given transformation of all (key, value) ,
        pairs using the given reducer to combine values, 
        and the given basis as an identity value.
        
      • Returns the result of accumulating the given transformation of all 
        (key, value) pairs using the given reducer to combine values, 
        and the given basis as an identity value.
        
      • Returns the result of accumulating all values ,
        using the given reducer to combine values, or null if none.
        
      • Returns the result of accumulating the given transformation ,
        of all values using the given reducer to combine values, 
        or null if none.
        
      • Returns the result of accumulating the given transformation,
        of all values using the given reducer to combine values, 
        and the given basis as an identity value.
        
      • Returns the result of accumulating the given transformation,
        of all values using the given reducer to combine values, 
        and the given basis as an identity value.
        
      • Returns the result of accumulating the given transformation of all values,
        using the given reducer to combine values, and 
        the given basis as an identity value.
        
      • Returns a non-null result from applying the given,
        search function on each (key, value), or null if none. 
        Upon success, further element processing is suppressed ,
        and the results of any other parallel invocations ,
        of the search function are ignored.
        
      • Returns a non-null result from applying the given,
        search function on each entry, or null if none.
        Upon success, further element processing is suppressed ,
        and the results of any other parallel invocations,
        of the search function are ignored.
        
      • Returns a non-null result from applying the given,
        search function on each entry, or null if none.
        Upon success, further element processing is suppressed ,
        and the results of any other parallel invocations,
        of the search function are ignored.
        
      • Returns a non-null result from applying the given,
        search function on each entry, or null if none.
        Upon success, further element processing is suppressed ,
        and the results of any other parallel invocations,
        of the search function are ignored.
        
      • Returns an enumeration of the values in this table.
        
      • Returns an enumeration of the keys in this table.
        
        New Methods Does This
        1.forEach​(long parallelismThreshold, BiFunction transformer, Consumer action)

        A comparison function, which imposes a total ordering on some collection of objects. Comparators can also be used to control the order of sorted maps . Here,It returns the comparator used to order the keys in this map, or null if this map uses the natural ordering of its keys.

        2.forEach​(long parallelismThreshold, BiConsumer action)

        Performs the given action for each (key, value).

        3.forEachEntry​(long parallelismThreshold, Consumer action)

        Performs the given action for each (key, value).

        4.forEachEntry​(long parallelismThreshold, Function,​? extends U> transformer, Consumer action)

        Performs the given action for each non-null transformation of each entry.

        5.forEachKey​(long parallelismThreshold, Consumer action)

        Performs the given action for each non-null transformation of each entry.

        6.forEachKey​(long parallelismThreshold, Function transformer, Consumer action)

        Performs the given action for each non-null transformation of each key.

        7.forEachKey​(long parallelismThreshold, Consumer action)

        Performs the given action for each value.

        8. forEachValue​(long parallelismThreshold, Functiontransformer, Consumer action)

        Performs the given action for each non-null transformation of each value.

        8. forEachValue​(long parallelismThreshold, Functiontransformer, Consumer action)

        Performs the given action for each non-null transformation of each value.

        9. keySet​(V mappedValue)

        Returns a Set view of the keys in this map, using the given common mapped value for any additions (i.e., Collection.add and Collection.addAll(Collection)). This is of course only appropriate if it is acceptable , to use the same value for all additions from this view.

        Which means if a Set's object is set to Map's keyset with its Mapped Value and if we continue to add with Collection.add () function through set the , added values will be refered as "Keys" of the map , automatically gets added to Map as "Keys" gets mapped with the given Value.

        10. MappingCount

        Returns the number of mappings. This method should be used instead of size . The reason is, a ConcurrentHashMap may contain more mappings, than can be represented as an int. The value returned is an estimate; the actual count may differ ,if there are concurrent insertions or removals.

        11. newKeySet()

        Creates a new Set backed by a ConcurrentHashMap,from the given type to Boolean.TRUE.

        12. newKeySet(int initialCapacity)

        Creates a new Set backed by a ConcurrentHashMap,from the given type to Boolean.TRUE.

        13. reduce​(long parallelismThreshold, BiFunction transformer, BiFunction reducer)

        Returns the result of accumulating the given transformation ,of all (key, value) pairs using the given reducer ,to combine values, or null if none.

        14. reduceEntries​(long parallelismThreshold, BiFunction,​Map.Entry,​? extends Map.Entry> reducer)

        Returns the result of accumulating all entries ,using the given reducer to combine values, or null if none.

        15. reduceEntries​(long parallelismThreshold, Function,​? extends U> transformer, BiFunction reducer)

        Returns the result of accumulating the given transformation,of all entries using the given reducer to combine values, or null if none.

        16. reduceEntriesToDouble​(long parallelismThreshold, ToDoubleFunction> transformer, double basis, DoubleBinaryOperator reducer)

        Returns the result of accumulating the given transformation ,of all entries using the given reducer to combine values, and the given basis as an identity value.

        17. reduceEntriesToInt​(long parallelismThreshold, ToIntFunction> transformer, int basis, IntBinaryOperator reducer)

        Returns the result of accumulating the given transformation ,of all entries using the given reducer to combine values, and the given basis as an identity value.

        18. reduceEntriesToLong​(long parallelismThreshold, ToLongFunction> transformer, long basis, LongBinaryOperator reducer)

        Returns the result of accumulating the given transformation,of all entries using the given reducer to combine values, and the given basis as an identity value.

        19.reduceKeys​(long parallelismThreshold, BiFunction reducer)

        Returns the result of accumulating all keys ,using the given reducer to combine values, or null if none.

        20.reduceKeys​(long parallelismThreshold, Function transformer, BiFunction reducer)

        Returns the result of accumulating the given transformation,of all keys using the given reducer to combine values, or null if none.

        21. reduceKeysToDouble​(long parallelismThreshold, ToDoubleFunction transformer, double basis, DoubleBinaryOperator reducer)

        Returns the result of accumulating the given transformation,of all keys using the given reducer to combine values, and the given basis as an identity value.

        22. reduceKeysToInt​(long parallelismThreshold, ToIntFunction transformer, int basis, IntBinaryOperator reducer)

        Returns the result of accumulating the given transformation,of all keys using the given reducer to combine values, and the given basis as an identity value.

        23.reduceKeysToLong​(long parallelismThreshold, ToLongFunction transformer, long basis, LongBinaryOperator reducer)

        Returns the result of accumulating the given transformation,of all keys using the given reducer to combine values, and the given basis as an identity value.

        24.reduceToDouble​(long parallelismThreshold, ToDoubleBiFunction transformer, double basis, DoubleBinaryOperator reducer)

        Returns the result of accumulating the given transformation of all (key, value) pairs using the given reducer to combine values,and the given basis as an identity value.

        25. reduceToInt​(long parallelismThreshold, ToIntBiFunction transformer, int basis, IntBinaryOperator reducer)

        Returns the result of accumulating the given transformation of all (key, value) ,pairs using the given reducer to combine values, and the given basis as an identity value.

        26. reduceToLong​(long parallelismThreshold, ToLongBiFunction transformer, long basis, LongBinaryOperator reducer)

        Returns the result of accumulating the given transformation of all (key, value) pairs using the given reducer to combine values, and the given basis as an identity value.

        27. reduceValues​(long parallelismThreshold, BiFunction reducer)

        Returns the result of accumulating all values ,using the given reducer to combine values, or null if none.

        28. reduceValues​(long parallelismThreshold, Function transformer, BiFunction reducer)

        Returns the result of accumulating the given transformation ,of all values using the given reducer to combine values, or null if none.

        29. reduceValuesToDouble​(long parallelismThreshold, ToDoubleFunction transformer, double basis, DoubleBinaryOperator reducer)

        Returns the result of accumulating the given transformation,of all values using the given reducer to combine values, and the given basis as an identity value.

        30. reduceValuesToInt​(long parallelismThreshold, ToIntFunction transformer, int basis, IntBinaryOperator reducer)

        Returns the result of accumulating the given transformation,of all values using the given reducer to combine values, and the given basis as an identity value.

        31. reduceValuesToLong​(long parallelismThreshold, ToLongFunction transformer, long basis, LongBinaryOperator reducer)

        Returns the result of accumulating the given transformation of all values,using the given reducer to combine values, and the given basis as an identity value.

        32.search​(long parallelismThreshold, BiFunction searchFunction)

        Returns a non-null result from applying the given,search function on each (key, value), or null if none. Upon success, further element processing is suppressed ,and the results of any other parallel invocations ,of the search function are ignored.

        33. searchEntries​(long parallelismThreshold, Function,​? extends U> searchFunction)

        Returns a non-null result from applying the given,search function on each entry, or null if none.Upon success, further element processing is suppressed ,and the results of any other parallel invocations,of the search function are ignored.

        34. searchKeys​(long parallelismThreshold, Function searchFunction)

        Returns a non-null result from applying the given,search function on each entry, or null if none.Upon success, further element processing is suppressed ,and the results of any other parallel invocations,of the search function are ignored.

        35. searchValues​(long parallelismThreshold, Function searchFunction)

        Returns a non-null result from applying the given,search function on each entry, or null if none.Upon success, further element processing is suppressed ,and the results of any other parallel invocations,of the search function are ignored.

        36. Enumeration elements()

        Returns an enumeration of the values in this table.

        37. Enumeration keys()

        Returns an enumeration of the keys in this table.

      ConcurrentHashMap.KeySetView - Inner Class of ConcurrentHashMap

      sequenceDiagram
      
        java.util.concurrent.ConcurrentHashMap->>java.util.ConcurrentHashMap.KeySetView:InnerClass 
        java.util.ConcurrentHashMap.KeySetView->>java.util.concurrent.ConcurrentHashMap.CollectionView:extends
        java.util.ConcurrentHashMap.KeySetView->>java.util.Set:implements
        java.util.ConcurrentHashMap.KeySetView->>java.io.Serializable:implements
      
      
      Loading

      public class ConcurrentHashMap<K,V> extends AbstractMap<K,V>
          implements ConcurrentMap<K,V>, Serializable {
      
       ......
      
       public static final class KeySetView<K,V> extends CollectionView<K,V,K>
              implements Set<K>, java.io.Serializable
      
       ....
      
      }
      

      • 1. CollectionView class is an abstract class of ConcurrentHashMap class which is not viable or be imported to any file . Syntax as follows:
      • abstract static sealed class CollectionView<K,V,E>
                implements Collection<E>, java.io.Serializable 
        	permits EntrySetView, KeySetView, ValuesView
        

      • 2. More Over EntrySetView, KeySetView and ValuesView are "Static Final Classes" of "ConcurrentHashMap" class and are not viable or be imported to any file. Syntax as follows:
      • EntrySetView Class

        static final class EntrySetView<K,V> extends 
        	CollectionView<K,V,Map.Entry<K,V>>
                implements Set<Map.Entry<K,V>>, java.io.Serializable
        

        KeySetView Class

        public static final class KeySetView<K,V> extends CollectionView<K,V,K>
                implements Set<K>, java.io.Serializable
        

        ValuesView Class

        static final class ValuesView<K,V> extends CollectionView<K,V,V>
                implements Collection<V>, java.io.Serializable
        

      • 3. CollectionView class, EntrySetView class, KeySetView class and ValuesView class cannot be implemented directly but can be implemented through KeySetView as KeySetView , the inner class of ConcurrentHashMap class inherit those classes along with Set and Serializable interface.
      • 4. The main motive of KeySetView , the inner class of ConcurrentHashMap to store the Keys of the given Map as a Set in a Variable or object created by KeySet class or ConcurrentHashMap.KeySet class.
      • Implementation of ConcurrentHashMap.KeySetView class

ConcurrentSkipListMap

    sequenceDiagram
    
      java.util.concurrent.ConcurrentSkipListMap->>java.lang.Cloneable:implements
      java.util.concurrent.ConcurrentSkipListMap->>java.io.Serializable:implements
      java.util.concurrent.ConcurrentSkipListMap->>java.util.concurrent.ConcurrentNavigableMap:implements
      java.util.concurrent.ConcurrentSkipListMap->>java.util.AbstractMap:extends
      java.util.concurrent.ConcurrentNavigableMap->>java.util.ConcurrentMap:extends
      java.util.concurrent.ConcurrentNavigableMap->>java.util.NavigableMap:extends
      java.util.concurrent.ConcurrentMap->>java.util.Map:extends 
      java.util.NavigableMap->>java.util.SortedMap:extends 
      java.util.SortedMap->>java.util.Map:extends
      java.util.AbstractMap->>java.util.Map:implements
      java.util.AbstractMap->>java.lang.Object:extends
    
    
    Loading

    public class ConcurrentSkipListMap<K,​V> extends AbstractMap<K,​V> 
    		implements ConcurrentNavigableMap<K,​V>, Cloneable, Serializable
    		
    public abstract class AbstractMap<K,V> extends Object implements Map<K,V>
    
    public interface ConcurrentNavigableMap<K,V> extends ConcurrentMap<K,V>
                                                     , NavigableMap<K,V>
                                                     
    public interface ConcurrentMap<K,V> extends Map<K,V>
    public interface NavigableMap<K,V> extends SortedMap<K,V>
    public interface SortedMap<K, V> extends Map<K, V>
    

    • 1.The ConcurrentSkipListMap class is a member of the Java Collections Framework.

    • 2.The ConcurrentSkipListMap was introduced in JDK 1.6.

    • 3.The ConcurrentSkipListMap belongs to java.util.concurrent package.

    • 4.The ConcurrentSkipListMap is a scalable implementation of ConcurrentNavigableMap.

    • 5.All the elements of ConcurrentSkipListMap sorted based on natural ordering or by the Comparator passed during it’s construction time.

    • 6.This class uses a concurrent variation of SkipList data structure providing log(n) time cost for insertion, removal, update, and access operations.

    • 7.These operations are safe for executing concurrently by multiple threads. (ConcurrentSkipListMap is thread-safe.)

    Constructors of ConcurrentSkipListMap

    • Constructs a new, empty map, sorted according to the natural ordering of the keys.
      
    • 2.ConcurrentSkipListMap​(Comparator comparator)

      • Constructs a new, empty map, sorted according to the specified comparator.
        
        Note: 
        
        1. ConcurrentSkipListMap<Key, Value> map = 
        new ConcurrentSkipListMap<>((a, b) -> b.compareTo(a))
        
        2. Comparator<? super Key> comparator = map.comparator();
        
        ConcurrentSkipListMap<Key, Value> map = 
        new ConcurrentSkipListMap<>(comparator)
        
        
      • Constructs a new, empty map, sorted according to the specified comparator.
        
        Here Class implements Comparator interface for comparison.
        
        Generally negative comparison : ReverseOrder
        
        Generally positive comparison : AscendingOrder/NaturalOrder
        
      • Constructs a new, empty map, sorted according to the specified comparator.
        
        Here Comparator object is passed inside Constructor.
        
        Generally negative comparison : ReverseOrder
        
        Generally positive comparison : AscendingOrder/NaturalOrder
        
        
      • Constructs a new, empty map, sorted according to the specified comparator.
        
        Here Direct Comparator Class is called inside Constructor.
        
        Comparator.reverseOrder(): Gives Reverse Order of Values
        Comparator.naturalOrder(): Gives Natural Order of Values
        
        Any negative comparison : ReverseOrder
        
        Any positive comparison : AscendingOrder/NaturalOrder
        
    • Constructs a new map containing the same mappings as the given map, 
      sorted according to the natural ordering of the keys.​
      
      
    • Constructs a new map containing the same mappings and 
      using the same ordering as the specified sorted map.
      
      

      Methods of ConcurrentSkipListMap

F. Map.Entry Interface (Sub Interface of Map Interface) and Map.of()

HashTable Class

    sequenceDiagram
    
       java.util.HashTable->>java.util.Dictionary:extends 
       java.util.HashTable->>java.util.Map:implements
       java.util.HashTable->>java.io.Serializable:implements
      java.util.HashTable->>java.lang.Cloneable:implements
      
    
    
    
    Loading

    public class Hashtable<K,V> extends Dictionary<K,V> 
    		implements Map<K,V>, Cloneable, Serializable
    

    Note : Details of HashTable class is explained 👉 Link Here