HashMap in Java

A HashMap is a part of Java’s Collection Framework and implements the Map interface. It stores elements in key-value pairs, where, Keys are unique. and Values can be duplicated.

• Internally uses Hashing, hence allows efficient key-based retrieval, insertion, and removal with an average of O(1) time.
• HashMap is not thread-safe, to make it synchronized, use Collections.synchronizedMap().
• Insertion order is not preserved in HashMap. To preserve the insertion order, LinkedHashMap is used and to maintain sorted order, TreeMap is used.
• HashMap allows one null key and multiple null values. If a null key is added multiple times, it overwrites the previous value.

John -> 25
Jane -> 30
Jim -> 35

HashMap Declaration

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

It takes two parameters, namely as follows:

• K -> Type of keys maintained by this map
• V -> Type of mapped values

Note: Order is not guaranteed in HashMap output may vary when you run your program

Hierarchy of HashMap in Java

It extends AbstractMap and implements the Map Interface.

Capacity of HashMap

The capacity of a HashMap is the number of buckets it can hold for storing entries.

new capacity=old capacity×2

• Default capacity: Default capacity of hashmap is 16.
• Load factor: 0.75 (default): when 75% of the capacity is filled, the capacity is doubled.

Constructors of HashMap

HashMap provides 4 constructors and the access modifier of each is public.

1. HashMap()

It is the default constructor which creates an instance of HashMap with an initial capacity of 16 and a load factor of 0.75.

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

2. HashMap(int initialCapacity)

It creates a HashMap instance with a specified initial capacity and load factor of 0.75.

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

3. HashMap(int initialCapacity, float loadFactor)

It creates a HashMap instance with a specified initial capacity and specified load factor.

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

4. HashMap(Map map)

It creates an instance of HashMap with the same mappings as the specified map.

Map<Integer, String> map = new HashMap<>();
HashMap<Integer, String> hm = new HashMap<>(map);

Performing Various Operations on HashMap

1. Adding Elements in HashMap in Java

To add an element to the map, we can use the put() method. However, the insertion order is not retained in the Hashmap.

Mappings of HashMap hm1 are : {1=Geeks, 2=For, 3=Geeks}
Mapping of HashMap hm2 are : {1=Geeks, 2=For, 3=Geeks}

2. Accessing Elements in HashMap (Using get() Method)

It is used to retrieve the value associated with a given key from the HashMap, returning null if the key is not present.

Output:

Age of John: 25
Age of Jane: 30

All entries: John -> 25
Jane -> 30
Jim -> 35

3. Changing Elements in HashMap in Java

We can change a value in a HashMap by using the put() method with the same key, which replaces the old value with the new one.

Initial Map {1=Geeks, 2=Geeks, 3=Geeks}
Updated Map {1=Geeks, 2=For, 3=Geeks}

4. Removing Element from Java HashMap

To remove an element from the Map, we can use the remove() method. It removes the mapping for the specified key if it is present and returns the value associated with that key, or null if the key is not found.

Mappings of HashMap are : {1=Geeks, 2=For, 3=Geeks, 4=For}
Mappings after removal are : {1=Geeks, 2=For, 3=Geeks}

5. Traversal of Java HashMap

We can use an Iterator with Map.Entry<?, ?> to traverse a HashMap and print its entries using the next() method.

Key: vaibhav Value: 20
Key: vishal Value: 10
Key: sachin Value: 30

Time and Space Complexity

• HashMap provides constant time complexity for basic operations.
• In the worst case, HashMap operations can take O(N) time due to hash collisions.

Methods of HashMap

 Methods inherited from class java.util.AbstractMap

Methods inherited from interface java.util.Map

Recommended DSA Problems On HashMap

1. Count Frequencies in an Array
2. Most Frequent Element
3. Count distinct elements in every window of size K
4. Check if two arrays are equal or not
5. 2 Sum - Count Pairs with target sum
6. Count all pairs with absolute difference equal to K
7. Check If Array Pair Sums Divisible by K
8. Max distance between two occurrences in array
9. Subarray with Given Sum – Handles Negative Numbers
10. Remove minimum elements such that no common elements exist in two arrays
11. 3 Sum - Count all triplets with target sum
12. Longest Subarray with Sum Divisible by K
13. Longest Subarray having Majority Elements Greater than K