0 0
WP Ad Inserter plugin
Read Time:16 Second

Since Java 1.2, HashMap<Key, Value> has been part of the Java collection. The java.util package contains this class. It implements the Java Map interface in its most basic form. It holds data as (Key, Value) pairs that can be accessed using a different index type (e.g., an Integer). A key (index) refers to another object (value). Trying to insert the duplicate key overwrites the associated key’s element.

HashMap is comparable to HashTable but without synchronization. It also allows for the storage of null keys. However, there should only be one null key object and an unlimited number of null values. This class does not guarantee the order of the Map. Import the java.util. HashMap package or its superclass to utilize this class and its methods.

// program for illustrating the HashMap class of java.util package in Java // First, import the HashMap class
import java.util.HashMap; // Main class
public class Codeunderscored { // Declaration of the Main method public static void main(String[] args) { // Creation of a hash map that is empty by declaring the object // of string and integer type HashMap<String, Integer> hashMap = new HashMap<>(); //elements' addition to the Map using the standard method put() hashMap.put("kane", 10); hashMap.put("rock", 30); hashMap.put("undertaker", 20); // Printing the size & content of the Hash Map System.out.println("Size of Hash Map is:- "+ hashMap.size()); // Printing the items in object of Map System.out.println(hashMap); // Checking for the presence of a key and, if so, printing the value using a random element if (hashMap.containsKey("kane")) { // Mapping Integer aVar = hashMap.get("kane"); // Printing the value's corresponding key System.out.println("value for key"+ " "kane" is:- " + aVar); } }
}

The syntax is as follows:

public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable

It accepts two parameters, which are as follows:

  • The type of keys that this map keeps track of
  • The mapped values’ type

HashMap implements serializable, Cloneable, and Map<K, V> interfaces. AbstractMap<K, V> is extended by HashMap. LinkedHashMap and PrinterStateReasons are direct subclasses.

SUGGESTED READ

  • HashMap constructors are as follows:
  • HashMap has four constructors, each of which has a public access modifier and is listed below:
  • HashMap()
  • HashMap (int initialCapacity)
  • HashMap (int initialCapacity, float loadFactor)
  • HashMap (Map map)

We’ll go over each of the constructors and how to build them using clean Java programs.

The first Constructor: HashMap()

It’s the default constructor, and it generates a HashMap instance with a capacity of 16 and a load factor of 0.75.

The syntax is as follows:

HashMap<K, V> hashMap = new HashMap<K, V>();

Example: Program for demonstrating how to use the HashMap() constructor in Java

// Importing the necessary classes required
import java.io.*;
import java.util.*; // The Primary class for adding elements to the HashMap class Codeunderscored { // Main static method in java public static void main(String args[]) { // There is absolutely no reason for mentioning the Generic type twice HashMap<Integer, String> hashMapOne = new HashMap<>(); // Initializing the HashMap using Generics HashMap<Integer, String> hashMapTwo = new HashMap<Integer, String>(); // Adding elements using put method // Custom input elements hashMapOne.put(3, "three"); hashMapOne.put(4, "four"); hashMapOne.put(5, "five"); hashMapTwo.put(7, "seven"); hashMapTwo.put(8, "eight"); hashMapTwo.put(9, "Nine"); // Print and show the mapping of HashMap 1 System.out.println("The Mappings of the HashMap hashMapOne are : "+ hashMapOne); // Print and show the mapping of HashMap 2 System.out.println("The Mapping of the HashMap hashMapTwo are : "+ hashMapTwo); }
}

The output is as follows:

SUGGESTED READ

The Mappings of HashMap hashMapOne are : {3=three, 4=four, 5=five}
The Mapping of HashMap hashMapTwo are : {7=seven, 8=eight, 9=nine}

Second Constructor: HashMap(int initialCapacity)

It generates a HashMap object with a 0.75 load factor and a specified initial capacity. The syntax is as follows:

HashMap<K, V> hashMap = new HashMap<K, V>(int initialCapacity);

Example: Program for demonstrating HashMap(int initialCapacity) Constructor in Java

// Importing the necessary needed classes
import java.io.*;
import java.util.*; // The primary class to add HashMap items
class pushElementsToHashMap { // Main driver method public static void main(String args[]) { //It's needless repeating the Generic type. HashMap<Integer, String> hashMapOne = new HashMap<>(10); // Initialization of a HashMap using Generics HashMap<Integer, String> hashMapTwo = new HashMap<Integer, String>(2); // Adding elements to object of HashMap // using put method // HashMap One hashMapOne.put(4, "four"); hashMapOne.put(5, "five"); hashMapOne.put(6, "six"); // HashMap Two hashMapTwo.put(7, "seven"); hashMapTwo.put(8, "eight"); hashMapTwo.put(9, "nine"); // Print HashMap One elements System.out.println("The Mappings of the HashMap hashMapOne are : " + hashMapOne); // Print HashMap Two elements System.out.println("The Mapping of the HashMap hashMapTwo are : " + hashMapTwo); }
}

The resultant output is as follows:

The Mappings of the HashMap hashMapOne are: {4=four, 5=five, 6=six}
The Mapping of the HashMap hashMapTwo are: {7=seven, 8=eight, 9=nine}

The third Constructor: HashMap(int initialCapacity, float loadFactor)

It generates a HashMap instance with the initial capacity and load factor supplied. The syntax is as follows:

HashMap<K, V> hashMap= new HashMap<K, V>(int initialCapacity, int loadFactor);

Example: Program for demonstrating HashMap(int initialCapacity,float loadFactor) Constructor in Java

SUGGESTED READ

// Importing the standard needed classes
import java.io.*;
import java.util.*; // The primary class for adding elements to the HashMap
class Codeunderscored { // Declaration of the Main driver method public static void main(String args[]) { // It is needless to mention the generic type a second time HashMap<Integer, String> hashMapOne = new HashMap<>(5, 0.75f); // Initialization of a HashMap using Generics HashMap<Integer, String> hashMapTwo = new HashMap<Integer, String>(3, 0.5f); // using the put() method to add customized input elements // HashMap One hashMapOne.put(4, "four"); hashMapOne.put(5, "five"); hashMapOne.put(6, "six"); // HashMap Two hashMapTwo.put(7, "seven"); hashMapTwo.put(8, "eight"); hashMapTwo.put(9, "nine"); // Printing and showing elements in the hashMap one object System.out.println("The Mappings of the HashMap hashMapOne are : " + hashMapOne); // Printing and showing elements in the hashMap two object System.out.println("The Mapping of HashMap the hashMapTwo are : " + hashMapTwo); }
}

The resultant output is as follows:

The Mappings of the HashMap hashMapOne are: {4=four, 5=five, 6=six}
The Mapping of the HashMap hashMapTwo are: {7=seven, 8=eight, 9=nine}

HashMap(Map map)

This method produces a HashMap object with the same mappings as the given map. The syntax is as follows:

HashMap<K, V> hashMap = new HashMap<K, V>(Map map);

Example: Program for demonstrating the HashMap(Map map) Constructor in Java

import java.io.*;
import java.util.*; class pushElementsToHashMap { public static void main(String args[]) { // It is needless mentioning the Generic type twice Map<Integer, String> hashMapOne = new HashMap<>(); // Add Elements using put method hashMapOne.put(1, "one"); hashMapOne.put(5, "five"); hashMapOne.put(10, "ten"); // Initializing the HashMap using Generics HashMap<Integer, String> hashMapTwo = new HashMap<Integer, String>(hashMapOne); System.out.println("The Mappings of the HashMap hashMapOne are : " + hashMapOne); System.out.println("The Mapping of the HashMap hashMapTwo are : " + hashMapTwo); }
}

Output

The Mappings of the HashMap hashMapOne are : {1=one, 5=five, 10=ten}
The Mapping of the HashMap hashMapTwo are : {1=one, 5=five, 10=ten}

Using HashMap to Perform Various Operations

Adding Elements

The put() method can add an element to the map. The Hashmap, on the other hand, does not keep track of the insertion order.

SUGGESTED READ

Internally, a different hash is generated for each element, and the elements are indexed based on this hash to improve efficiency.

Example: Program for adding elements to a given HashMap in Java

import java.io.*;
import java.util.*; class pushElementsToHashMap { public static void main(String args[]) { // It is needless mentioning the Generic type twice HashMap<Integer, String> hashMapOne = new HashMap<>(); // Initialization of a HashMap // using Generics HashMap<Integer, String> hashMapTwo = new HashMap<Integer, String>(); // Add Elements using put method hashMapOne.put(1, "Code"); hashMapOne.put(2, "Underscored"); hashMapOne.put(3, "Dotcom"); hashMapTwo.put(1, "Code"); hashMapTwo.put(2, "Underscored"); hashMapTwo.put(3, "Dotcom"); System.out.println(" The Mappings of the HashMap hashMapOne are : " + hashMapOne); System.out.println("The Mapping of HashMap the hashMapTwo are : " + hashMapTwo); }
}

The resultant output is as follows:

The Mappings of the HashMap hm1 are: {1=Code, 2=Underscored, 3=Dotcom}
The Mapping of HashMap the hm2 are: {1=Code, 2=Underscored, 3=Dotcom}

Changing Elements

Just in case we wish to change an element after it has been added, we can do it by using the put() method to add it again. Because the keys are used to index the items in the map, the value of the key can be altered by simply adding the updated value for the key we want to change.

Example: Program for changing the elements of the HashMap in Java

SUGGESTED READ

import java.io.*;
import java.util.*;
class ChangeElementsOfHashMap { public static void main(String args[]) { // Initializing the HashMap HashMap<Integer, String> hashMapOne = new HashMap<Integer, String>(); // Changing the specified value using the put method hashMapOne.put(1, "Code"); hashMapOne.put(2, "Underscored"); hashMapOne.put(3, "Dotcom"); System.out.println("Initial Map " + hashMapOne); hashMapOne.put(2, "Coding"); System.out.println("Updated Map " + hashMapOne); }
}

Removing an Element

The remove() function can delete an element from the Map. If a key is present in the map, this function takes the key value and removes the mapping for that key.

Example: Program for removing the elements from the HashMap in Java

import java.io.*;
import java.util.*; class RemovingHashMapElements{ public static void main(String args[]) { // Initializing the HashMap Map<Integer, String> hashMapOne = new HashMap<Integer, String>(); // Add elements using put method hashMapOne.put(1, "Code"); hashMapOne.put(2, "Underscored"); hashMapOne.put(3, "Dotcom"); hashMapOne.put(4, "Coding"); // Initializing the HashMap System.out.println("The Mappings of the HashMap are : " + hashMapOne); // removing the element with a key using the given remove method hashMapOne.remove(4); // Finalizing the HashMap System.out.println("The respective Mappings after removal are : " + hashMapOne); }
}
The Mappings of the HashMap are: {1=Code, 2=Underscored, 3=Dotcom, 4=Coding}
The Mappings after removal are: {1=Code, 2=Underscored, 3=Dotcom}

HashMap traversal

The Iterator interface can be used to explore any Collection Framework structure. Do we utilize Entry<? , ? > to resolve the two different types into a suitable format because Iterators only work with one data type. The items of HashMap are then printed using the next() method.

// Example: Program for traversing a Java.util.HashMap import java.util.HashMap;
import java.util.Map; public class HashMapTraversal { public static void main(String[] args) { // initialize a HashMap HashMap<String, Integer> hashMapOne = new HashMap<>(); // Add elements using put method hashMapOne.put("ken", 31); hashMapOne.put("white", 50); hashMapOne.put("brown", 90); // Iterate through the hash map using a for-each loop for (Map.Entry<String, Integer> entry : hashMapOne.entrySet()) System.out.println("The key is: " + entry.getKey() + " The value is: " + entry.getValue()); }
}

HashMap’s Important Features

A key is required to access a value. HashMap is named after the Hashing technique that it employs. Hashing is a method for turning a long String into a short string representing the same String. A shorter value aids indexing and search speed. Internally, HashSet uses HashMap.

HashMap has a few notable features:

SUGGESTED READ

  • The java.util package includes HashMap.
  • HashMap is an abstract class that extends AbstractMap and provides a partial implementation of the Map interface.
  • Cloneable and Serializable interfaces are also implemented.
  • K and V stand for Key and Value in the preceding formulation.
  • Duplicate keys are not permitted in HashMap, although duplicate values are permitted.
  • A single key cannot hold more than one value, while several keys can hold a single value.
  • HashMap also supports null keys, but only once with numerous null values.
  • This class provides no claims about the map’s arrangement, including that it will remain stable over time.
  • It’s comparable to HashTable but without synchronization.

HashMap’s Internal Structure

HashMap internally includes an array of Nodes, each of which is represented by a class with four fields:

  • int hash
  • K key
  • V value
  • Next node

The node contains a reference to its object, as can be seen. As a result, it’s a linked list.

HashMap’s performance

HashMap’s performance is determined by two parameters, which are as follows:

  • Initial Capacity
  • Load Factor

Initial Capacity

This was HashMap’s capacity when it was created (The number of buckets a HashMap can hold when the HashMap is instantiated). It starts as 2^4=16 in Java, which means it can hold 16 key-value pairs.

Load Factor

This is the percentage of capacity that will be raised after Hashmap capacity increases (The percentage fill of buckets after rehashing takes place). The default value in Java is 0.75f, which means that rehashing occurs once 75 percent of the capacity has been filled.

SUGGESTED READ

Threshold

The product of the Load Factor and the Initial Capacity is the Threshold. It is (16 * 0.75 = 12) in Java by default. After entering 12 key-value pairs into the HashMap, rehashing occurs.

Rehashing

Rehashing doubles HashMap’s capacity when it has reached its Threshold. HashMap in Java continues to rehash in the following order (by default): 2^4, 2^5, 2^6, 2^7, etc.

Rehashing will never be done if the starting capacity is kept high. However, increasing it raises the temporal complexity of iteration. To improve performance, it should be carefully picked. To determine the starting capacity, consider the expected number of values. The most popular load factor number is 0.75, which offers a fair time and space costs balance. The value of the load factor varies between 0 and 1.

For your information, starting with Java 8, instead of utilizing a linked list for chaining, Java now uses Self Balancing BST. The benefit of self-balancing BST is that we obtain the worst-case search time (where every key maps to the same slot) O(Log n).

HashMap with synchronization

HashMap is unsynchronized, which means that many threads can access it simultaneously. External synchronization is required if multiple threads visit this class simultaneously and at least one of them manipulates its structure. It is accomplished by synchronizing a map-encapsulating object. It can be wrapped around Collections if no such object exists. To make HashMap synchronized and avoid unintended access, use synchronizedMap(). Consider the following scenario:

SUGGESTED READ

Map m = Collections.synchronizedMap(new HashMap(...));

The Map m has now been synced. If any structural alteration is made after the creation of the iterator, except through the iterator’s remove method, iterators of this class are fail-fast. It will throw ConcurrentModificationException if the iterator fails.

HashMap’s time complexity

If the hash function is appropriately built and the contents are distributed evenly throughout the buckets, HashMap provides constant time complexity for simple operations like getting and putting.

Iteration over HashMap is limited by HashMap’s capacity and the amount of key-value pairs. In essence, it is proportionate to the capacity + size. In HashMap, capacity refers to the number of buckets. As a result, keeping many buckets in HashMap at first is not a good idea.

HashMap’s Applications

HashMap is primarily a hashing implementation. It comes in handy when we need to quickly implement search, insert, and delete operations.

HashMap’s methods

K – refers to the kind of keys on the map.

SUGGESTED READ

V – refers to the kind of values mapped in the given map.

Clear()

This map’s mappings are completely removed using this method.

Clone()

This HashMap instance is returned as a shallow copy; the keys and values are not duplicated.

compute(K keyVal, codeFunction<? super K, ? super V,? extends V> rMappingFunction)

Calculates a mapping between the provided key and its current mapped value (or null if there is no current mapping).

computeIfPresent(K keyVal, codeFunction<? super K, ? super V,? extends V> rMappingFunction)

If the specified key’s values are present and non-null, attempts to generate a new mapping given the key and its existing mapped value.

SUGGESTED READ

containsKey(Object key)

If this map has a mapping for the supplied key, it returns true.

containsValue(Object value)

If this map by any chance maps to one or more keys to the supplied value, it returns true.

entrySet()

This method is responsible for returning a Set view of the mappings in this map.

get(Object key)

Returns the value to which the supplied key is mapped, or null if no mapping for the key exists in this map.

computeIfAbsent(K keyVal, Function<? super K,? extends V> mappingFunction)

Attempts to compute the value of the supplied key using the given mapping function and enters it into this map if it is not already connected with a value (or is mapped to null).

SUGGESTED READ

IsEmpty()

If this map has no key-value mappings, it returns true.

keySet()

This method is responsible for returning a Set view of the keys in this map.

merge(K keyVal, V valueVal, BiFunction<? super V, ? super V,? extends V> remappingFunction)

Associates the provided key with the given non-null value if it is not already associated with a value or is null.

put(K key, V value)

This map associates the supplied value with the specified key.

putAll(Map<? extends K,? extends V> m)

All mappings from the specified map are copied to this map.

SUGGESTED READ

remove(Object key)

If a mapping for the supplied key exists in this map, it is removed.

Size()

It is responsible for returning the number of key-value mappings in this map.

Values()

This method returns a Collection view of the values in this map.

Methods that have been inherited from the java.util.AbstractMap class

equals()

Checks for equality between the provided object and this map.

hashCode()

The method is responsible for returning the hash code value for this map.

SUGGESTED READ

toString()

The toString() method is responsible for returning this map’s string representation.

Methods that have been inherited from the java.util.Map interface

equals()

Checks for equality between the provided object and this map.

forEach(BiConsumer<? super K,? super V> action)

Performs the supplied action for each entry in this map until the action throws an exception. Or all entries have been processed.

getOrDefault(Object key, V defaultValue)

Returns the value to which the supplied key is mapped, or defaultValue if no mapping for the key exists in this map.

hashCode()

It returns the hash code value for this map.

SUGGESTED READ

putIfAbsent(K key, V value)

If the specified key does not already have a value (or is mapped to null), it is associated with the given value and returns null; otherwise, it returns the current value.

remove(Object key, Object value)

The entry is removed if the supplied key is currently mapped to the specified value.

replace(K key, V value)

It is replaced only if the provided key is currently mapped to a value.

replace(K key, V oldValue, V newValue)

If the provided key is currently mapped to the supplied value, it is replaced.

replaceAll(codeFunction<? super K,? super V,? extends V> function)

Replace the value of each entry with the result of running the supplied function on that entry until all entries have been processed. Or the function throws an error.

SUGGESTED READ

Example: HashMap in Java

 import java.util.*; public class CodeHashMap{ public static void main(String args[]){ HashMap<Integer,String> hashMap=new HashMap<Integer,String>();//Creating HashMap hashMap.put(1,"Apple"); //Add items in hashMap hashMap.put(2,"Amazon"); hashMap.put(3,"Google"); hashMap.put(4,"Yahoo"); hashMap.put(5,"Twitter"); hashMap.put(6,"Uber"); hashMap.put(7,"DELL"); System.out.println("Iterating through the Hashmap"); for(Map.Entry m : hashMap.entrySet()){ System.out.println(m.getKey()+" "+m.getValue()); } } } 

We’re storing Integer as the key and String as the value in this example. Thus, the type is HashMap<Integer, String>. The elements are placed on the map using the put() method. The getKey() and getValue() methods should be used to retrieve the key and value items, respectively. The getKey() and getValue() functions are part of the Map.Entry interface.

To get an instance of Map.Entry, we must use the Map interface’s entrySet() method.

Example: HashMap has no duplicate keys

HashMap does not allow duplicate keys to be stored. If you try to store a duplicate key with a different value, the value will be replaced.

 import java.util.*; public class HashMapExample2{ public static void main(String args[]){ HashMap<Integer,String> map=new HashMap<Integer,String>();//Creating HashMap hashMap.put(1,"Apple"); //Add items in hashMap hashMap.put(2,"Amazon"); hashMap.put(3,"Google"); hashMap.put(4,"Yahoo"); hashMap.put(5,"Twitter"); hashMap.put(6,"Uber"); hashMap.put(7,"DELL"); hashMap.put(1,"IBM"); //trying to create a duplicate key System.out.println("Iterating through the Hashmap"); for(Map.Entry m : hashMap.entrySet()){ System.out.println(m.getKey()+" "+m.getValue()); } } } 

Example: Adding components to a Java HashMap

Different approaches to adding items to a HashMap in Java are shown here.

 import java.util.*; class CodeHashMap{ public static void main(String args[]){ HashMap<Integer,String> hashMap=new HashMap<Integer,String>(); System.out.println("The initial item's list : "+hashMap); hashMap.put(230,"Ken"); hashMap.put(240,"Mike"); hashMap.put(250,"White"); System.out.println("Results after invoking the put() method "); for(Map.Entry m:hashMap .entrySet()){ System.out.println(m.getKey()+" "+m.getValue()); } hashMap.putIfAbsent(260, "Joy"); System.out.println("Results proceeding invoking putIfAbsent() method "); for(Map.Entry m:hashMap .entrySet()){ System.out.println(m.getKey()+" "+m.getValue()); } HashMap<Integer,String> hashMapTwo=new HashMap<Integer,String>(); hashMapTwo.put(270,"Brown"); hashMapTwo.putAll(hashMap); System.out.println(" Results following invoking putAll() method "); for(Map.Entry m:hashMapTwo .entrySet()){ System.out.println(m.getKey()+" "+m.getValue()); } } } 

Example: Removing entries from a Java HashMap

Different methods for removing items are shown here.

SUGGESTED READ

 import java.util.*; public class CodeHashMap { public static void main(String args[]) { HashMap<Integer,String> hashMap=new HashMap<Integer,String>(); hashMap.put(230,"Ken"); hashMap.put(240,"Mike"); hashMap.put(250,"White"); hashMap.put(260, "Brown"); System.out.println(" The original list of elements is as follows: "+hashMap); //key-based removal hashMap.remove(230); System.out.println(" The resultant updated list of elements: "+hashMap); //value-based removal hashMap.remove(240); System.out.println("The new updated list of elements: "+hashMap); //key-value pair based removal hashMap.remove(260, "Brown"); System.out.println("The resulting updated list of elements: "+hashMap); } } 

Example: Replace() items in a Java HashMap

Different approaches to replacing items are as follows:

 import java.util.*; class CodeHashMap{ public static void main(String args[]){ HashMap<Integer,String> hashMap=new HashMap<Integer,String>(); hashMap.put(230,"Ken"); hashMap.put(240,"Mike"); hashMap.put(250,"White"); hashMap.put(260, "Brown"); System.out.println(" The original element's list is:"); for(Map.Entry m:hashMap.entrySet()) { System.out.println(m.getKey()+" "+m.getValue()); } System.out.println("The new updated list of elements:"); hashMap.replace(240, "Joy"); for(Map.Entry m:hashMap .entrySet()) { System.out.println(m.getKey()+" "+m.getValue()); } System.out.println("The resultant refreshed list of elements:"); hm.replace(230, "Rock", "Undertaker"); for(Map.Entry m:hashMap.entrySet()) { System.out.println(m.getKey()+" "+m.getValue()); } System.out.println("The new resultant list of elements:"); hashMap.replaceAll((k,v) -> "Bright"); for(Map.Entry m:hashMap .entrySet()) { System.out.println(m.getKey()+" "+m.getValue()); } } } 

Example: The distinction between HashSet and HashMap

HashSet only includes values, whereas HashMap only contains entries (key and value).

 import java.util.*; class Laptop { int id; String name,owner,manufacturer; int count; public Laptop(int id, String name, String owner, String manufacturer, int count) { this.id = id; this.name = name; this.owner = owner; this.manufacturer = manufacturer; this. count = count; } } public class CodeHashMap { public static void main(String[] args) { //Creating map of Laptops Map<Integer,Laptop> hashMap=new HashMap<Integer,Laptop>(); //Creating Laptops Laptop laptopOne=new Laptop(1,"Lenovo","Tyson","Lenovo",2); Laptop laptopTwo=new Laptop(2,"HP","James","HP",1); Laptop laptopThree=new Laptop(3,"DELL","Green","DELL",3); //Adding Laptops to a hash map hashMap.put(1,laptopOne); hashMap.put(2,laptopTwo); hashMap.put(3,laptopThree); //how to traverse the map for(Map.Entry<Integer, Laptop> entry:map.entrySet()){ int key=entry.getKey(); Laptop laptop=entry.getValue(); System.out.println(key+" Details:"); System.out.println(laptop .id+" "+laptop.name+" "+laptop.owner+" "+laptop.manufacturer+" "+laptop.count); } } } 

Conclusion

The Map interface in Java is implemented by the HashMap class, which allows us to store key-value pairs with unique keys. Attempts to insert a duplicate key cause the corresponding key’s element to be overwritten. The key index makes updating, removing, and other operations easier.

The HashMap class is found in java.util package. In Java, HashMap is similar to Hashtable. However, it is not synchronized. It also allows us to store null elements, although only one null key should be used. HashMap<K, V> has been used since Java 5, where K stands for key and V stands for value. It implements the Map interface and inherits the AbstractMap class.

Source: https://www.codeunderscored.com/hashmap-in-java/

PriorityQueue in Java explained with examples Previous post PriorityQueue in Java explained with examples
Python While Loop statements with examples Next post Python While Loop statements with examples

Leave a Reply

Your email address will not be published.

This site uses Akismet to reduce spam. Learn how your comment data is processed.