HashMap in Java: A Complete Guide

HashMap in Java falls under the most commonly used data structures today. It is basically a collection based on Map that holds key-value pairs. They are used in Java when distinct keys are available for data that we aim to store. It is recommended to be used while searching for items based on a key.

The popularity of Java is on a constant rise. According to a report by Oracle, Java is used in more organisations than any other programming or development language. HashMap is one of the features of this globally acclaimed application. This Java HashMap blog explains in detail what a HashMap in Java is, how to create one, and an example of the HashMap class. Read along to learn more. 

Table of Contents

1) What is HashMap?

2) How to create a HashMap?

3) HashMap: Hierarchy

4) Constructors in HashMap

5) Methods in HashMapassociate 

6) HashMap: Advantages and Disadvantages

7) Conclusion

What is HashMap?

HashMap is a class that implements the Map interface in Java, providing a dynamic array to store key-value pairs. It utilises a Hashing mechanism for efficient data retrieval. Keys are hashed to determine their index in the array, enabling constant-time average performance for basic operations like get and put. 

HashMap allows null keys and values and permits a single null key. It's not synchronised, making it more efficient for non-thread-safe use cases. However, for thread-safe operations, alternatives like Hashtable or Concurrent HashMap are recommended. HashMap offers flexibility, speed, and ease of use, making it widely employed for associative array-based implementations in Java applications.

Features of HashMap

Java HashMap was termed so because it uses a technique called Hashing. Hashing is used for converting a large String to small String that represents the same String in Java.

The following are some of its significant features:

a) It contributes to extending an abstract class AbstractMap which also offers an incomplete implementation of Map interface.

b) It implements Cloneable and Serialisable interface in Java.

c) Key duplication is not allowed although value duplication is. This implies that a key cannot encompass more than one value, but more than one key can encompass a single value.

d) Java HashMap allows the null key once alongside multiple null values.


 

How to create a HashMap?

Now that you have read about the basics of HashMap and its features, it’s time to delve into the creation of a Java HashMap. Here's an example code snippet that forms an empty HashMap of type String for keys and Integer for values:

HashMap map = new HashMap<>();

This makes a new HashMap object with default initial capacity (which is 16) and default load factor (which is 0.75).

Operations on HashMap

There are various other operations that can be performed on Java HashMap. It allows you to add elements, change added elements, remove elements and traverse it. The following are examples of performing two operations on it in Java:

a) Adding elements: Here is an example of adding elements using the ‘put()’ method in Java.

import java.util.HashMap;
import java.util.Map;
public class Example
{
public static void main(String[] args)
{
// Create a new HashMap
Map map = new HashMap<>();
// Add some key-value pairs to the map
map.put("apple", 1);
map.put("banana", 2);
map.put("orange", 3);
// Print out the contents of the map
System.out.println(map);
}
}

In this example, we first make a new HashMap object in Java with a key type of ‘String’ and a value type of ‘Integer’. Then, we use the ‘put()’ method to add three key-value pairs to the map.

Then, the contents of the map is printed using the ‘println()’ method.

Output:

{apple=1, banana=2, orange=3}

This shows that the elements were successfully added to the map using the put() method in Java.

b) Removing Elements: The ‘remove()’ method can be used to remove elements from the Map. In this method, the key value is taken and it removes the mapping for a key . Here's an example of using the remove() method in Java:

import java.util.HashMap;
public class Example
{
public static void main(String[] args)
{
// create a new HashMap
HashMap map = new HashMap<>();
// add some key-value pairs to the map
map.put("Alice", 25);
map.put("Bob", 30);
map.put("Charlie", 35);
// print the original map
System.out.println("Original Map: " + map);
// remove an element from the map using the remove() method
Integer age = map.remove("Bob");
System.out.println("Removed " + age + " from the map.");
// print the updated map
System.out.println("Updated Map: " + map);
}
}

In this example, we make a new HashMap and add three key-value pairs to it. Then we print the original map using ‘System.out.println("Original Map: " + map);.’

Next, we use the ‘remove()’ method to remove the element with the key "Bob" from the map in Java. We store the value associated with "Bob" in the variable age so that we can print it later. Finally, we print the updated map using ‘System.out.println("Updated Map: " + map);.’

Output:

Original Map: {Charlie=35, Alice=25, Bob=30}

Removed 30 from the map.

Updated Map: {Charlie=35, Alice=25}

As you can see, the remove() method successfully removed the element with the key "Bob" from the map, and the updated map no longer contains this element.

HashMap hierarchy

As mentioned in the content above, the Java HashMap extends AbstractMap and implements Cloneable and Serializable interfaces at the same time. To completely grasp its concept, you must be familiar with its hierarchy. The above image is the hierarchical structure of the java.util.HashMap class.

Improve your understanding of Java EE APIs alongside primary concepts of Advance Java. Sign up for our Introduction to Java EE Training course now!

Constructors in HashMap

Being aware of the constructors in Java HashMap is a significant step into understanding them. There are a total of four constructors provided by Java in HashMap. The following are the four constructors:

a) HashMap(): This is the default constructor. An instance of HashMap is formed with a different value for load factor and initial capacity in Java – 0.75 and 16 respectively. 

b) HashMap(int initialCapacity): It helps to makes an instance with a specified initial capacity and a load factor of 0.75.

c) HashMap(int initialCapacity, float loadFactor): It helps to create an instance with a specified initial capacity and a specified load factor in Java. 

d) HashMap(Map map): It helps to make an instance with the same mappings as the map that was specified. 

Learn about the fundamentals of Java and programming with it. Resister for our Java Programming course now!

Methods in HashMapassociate

The list below describes some of the commonly used methods in HashMapassociate: 
 

HashMap: Advantages and disadvantages

Java HashMap comes with its own set of advantages and disadvantages. Despite having helpful features like the restriction of key duplication, it carries a set of disadvantages as well. Here’s a comprehensive list covering both aspects:

Advantages

HashMap comes with a ton of pros. One of its features is that it contributes to extending an abstract class AbstractMap which also offers an incomplete implementation of Map interface, in Java. Here are some of the advantages of Java HashMap:

a) Speedy Retrieval: The retrieval and insertion of elements are quick. This is because it offers continuous time access to elements.

b) Flexibility: It allows null keys and values. It can store key-value pairs of any data type in Java.

c) Easy to use: The easy interface of HashMap is a useful feature. This is because Java can implement it without difficulty.

d) Storage: While mapping keys to indices in an array, HashMap uses a hashing function. This helps in the instant lookup of values based on keys, and efficient data storage in Java.

Disadvantages

One of the biggest disadvantages of it in Java, is that the elements added to the map are not ordered, and hence the order isn’t preserved. Here are some of the similar disadvantages of Java HashMap:

a) No thread-safety: Data inconsistencies in Java increase if multiple threads access it simultaneously. Thus, they are not thread safe.

b) More Complex: Compared to simple lists or arrays, HashMaps can be more complex to comprehend in Java. This is especially true for beginners.

c) Performance Drop: Performance degradation is a very real possibility. Sometimes, due to poor implementation of the hashing function or a high load factor, the performance can be affected.

d) Higher memory usage: It can use more memory compared to other data structures in Java. This is because it uses an underlying array.

Conclusion

It has been established by now that one of the commonly used data structures is HashMap. You can even perform various operations on it. We hope that this blog has explained all the nuances associated with HashMap in Java, from types to usage of constructors, methods, the pros and cons. With this added knowledge, we hope that you’ll be able to traverse the intricacies of HashMaps more efficiently. 

Improve your understanding of JavaScript. Sign up for our JavaScript for Beginners course now!