Java HashMap

Overview

HashMap is map based collection class that is used for storing key & value pairs which is denoted as HashMap<K, V> or HashMap<Key, Value>. It won’t maintain the order of map. It is almost similar to Hashtable except that it is unsynchronized and permits nulls. HashMap is part of java.util package

For official documentation on HashMap please refer oracle docs

Points to Remember

• HashMap doesn’t allow duplicate keys but allows duplicate values. That means A single key can’t contain more than 1 value but more than 1 key can contain a single value.
• HashMap allows null key also but only once and multiple null values.
• HashMap also implements Cloneable and Serializable interface. K and V in the above definition represent Key and Value respectively.

HashMap Declaration

HashMap extends AbstractMap class and implements Map interface

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

Constructors of HashMap

• HashMap() : It will construct a default HashMap
• HashMap(Map<? extends K,? extends V> m) : Constructs a new HashMap with the same mappings as the specified Map.
• HashMap(int initialCapacity) : Constructs an empty HashMap with the specified initial capacity and the default load factor(0.75).
• HashMap(int initialCapacity, float loadFactor) : Constructs an empty HashMap with the specified initial capacity and load factor.

Map<String, String> map = new HashMap<String, String>();
Map<String, Object> map1 = new HashMap<String, Object>(map);
Map<String, Object> map2 = new HashMap<String, Object>(2);
Map<String, Object> map3 = new HashMap<String, Object>(2, 3);

Methods

HashMap Creation

import java.util.HashMap;
import java.util.Map;

public class HashMapExample {
	public static void main(String[] args) {
		Map<String, Object> map = new HashMap<String, Object>();
		map.put("Sumanth", 10);
		map.put("Vishal", 15);
		map.put("Best Selling Phone", "Nokia");
		System.out.println("Size of Map : " + map.size());
		for(String str : map.keySet()) {
			System.out.println("Key :" + str);
			System.out.println("Value :" + map.get(str).toString());
		}
	}
}

Size of Map : 3
Key :Sumanth
Value :10
Key :Vishal
Value :15
Key :Best Selling Phone
Value :Nokia

Accessing keys and modifying their associated value in a HashMap

Here in the below example we will discuss about following methods:

• How to check if a HashMap is empty | isEmpty()
• How to find the size of a HashMap | size()
• How to check if a given key exists in a HashMap | containsKey()
• How to check if a given value exists in a HashMap | containsValue()
• How to get the value associated with a given key in the HashMap | get()
• How to modify the value associated with a given key in the HashMap | put()

import java.util.HashMap;
import java.util.Map;

public class MethodsHashMap {
	public static void main(String[] args) {
		Map<String, String> userCityMapping = new HashMap<>();
		// Check if a HashMap is empty
		System.out.println("is userCityMapping empty? : " + userCityMapping.isEmpty());
		userCityMapping.put("Sumanth", "Hyderabad");
		userCityMapping.put("Durgesh", "Uttar Pradesh");
		userCityMapping.put("Sunil", "Rajumandry");
		System.out.println("userCityMapping HashMap : " + userCityMapping);
		// Find the size of a HashMap
		System.out.println("We have the city information of " + userCityMapping.size() + " users");
		String userName = "Sudha";
		// Check if a key exists in the HashMap
		if (userCityMapping.containsKey(userName)) {
			// Get the value assigned to a given key in the HashMap
			String city = userCityMapping.get(userName);
			System.out.println(userName + " lives in " + city);
		} else {
			System.out.println("City details not found for user " + userName);
		}
		// Check if a value exists in a HashMap
		if (userCityMapping.containsValue("Hyderabad")) {
			System.out.println("There is a user in the userCityMapping who lives in Hyderabad");
		} else {
			System.out.println("There is no user in the userCityMapping who lives in Hyderabad");
		}

		// Modify the value assigned to an existing key
		userCityMapping.put(userName, "Delhi");
		System.out.println(userName + " moved to a new city " + userCityMapping.get(userName)
				+ ", New userCityMapping : " + userCityMapping);
		// The get() method returns `null` if the specified key was not found in the
		// HashMap
		System.out.println("Sumanth's city : " + userCityMapping.get("Sumanth"));
	}
}

Output : 
is userCityMapping empty? : true
userCityMapping HashMap : {Durgesh=Uttar Pradesh, Sumanth=Hyderabad, Sunil=Rajumandry}
We have the city information of 3 users
City details not found for user Sudha
There is a user in the userCityMapping who lives in Hyderabad
Sudha moved to a new city Delhi, New userCityMapping : {Durgesh=Uttar Pradesh, Sudha=Delhi, Sumanth=Hyderabad, Sunil=Rajumandry}
Sumanth's city : Hyderabad

Remove Keys from HashMap

Here is the example that shows how to remove a key or values in HashMap

import java.util.HashMap;
import java.util.Map;

public class RemoveHashMap {
	public static void main(String[] args) {
		Map<String, String> map = new HashMap<String, String>();
		map.put("BBC", "News");
		map.put("TV", "Entertainment");
		map.put("Mobile", "Electronics");
		map.put("Refrigerator", "Need");
		map.put("Charger", "Mobile");
		System.out.println("Original Map...");
		System.out.println(map);
		String remElement1 = map.remove("BBC");
		System.out.println("Removed Element is : " + remElement1);
		
		String remElement2 = map.remove("TV");
		System.out.println("Removed Element is : " + remElement2);
		System.out.println("Map after remove...");
		System.out.println(map);
		
		System.out.println("Removing all elements...");
		map.clear();
		System.out.println(map);
	}
}

Output : 
Original Map...
{BBC=News, TV=Entertainment, Refrigerator=Need, Charger=Mobile, Mobile=Electronics}
Removed Element is : News
Removed Element is : Entertainment
Map after remove...
{Refrigerator=Need, Charger=Mobile, Mobile=Electronics}
Removing all elements...
{}

Sorting HashMap

Sort HashMap By Key

Here is the example for sorting HashMap by their keys

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

public class MapSortByKey {
	public static void main(String[] args) {
		HashMap<Integer, String> map = new HashMap<Integer, String>();
		map.put(10, "AA");
		map.put(15, "CC");
		map.put(90, "ZZ");
		map.put(54, "YY");
		map.put(21, "RR");
		map.put(66, "KK");
		map.put(0, "MM");
		System.out.println("Before Sorting:");
		Set set = map.entrySet();
		Iterator iterator = set.iterator();
		System.out.println(map);
		Map<Integer, String> hmap = new TreeMap<Integer, String>(map);
		System.out.println("After Sorting:");
		Set set2 = hmap.entrySet();
		Iterator iterator2 = set2.iterator();
		while (iterator2.hasNext()) {
			Map.Entry me2 = (Map.Entry) iterator2.next();
		}
		System.out.println(hmap);
	}
}

Output:
Before Sorting:
{0=MM, 66=KK, 21=RR, 54=YY, 10=AA, 90=ZZ, 15=CC}
After Sorting:
{0=MM, 10=AA, 15=CC, 21=RR, 54=YY, 66=KK, 90=ZZ}

Sort HashMap By Value

This example shows how to sort HashMap by its values

import java.util.List;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.Map;

public class MapSortByValue {
	public static void main(String[] args) {
		HashMap<String, Integer> unsortedMap = new HashMap<String, Integer>();

		// enter data into hashmap
		unsortedMap.put("Math", 98);
		unsortedMap.put("Social Studies", 85);
		unsortedMap.put("Biology", 91);
		unsortedMap.put("Physics", 95);
		unsortedMap.put("Civics", 79);
		unsortedMap.put("Geography", 80);
		System.out.println("Before Sorting Values...");
		System.out.println(unsortedMap);
		Map<String, Integer> sortedMap = sortByValue(unsortedMap);

		// print the sorted hashmap
		System.out.println("After Sorting Values...");
		System.out.println(sortedMap);
	}

	// function to sort hashmap by values
	public static HashMap<String, Integer> sortByValue(HashMap<String, Integer> hm) {
		// Create a list from elements of HashMap
		List<Map.Entry<String, Integer>> list = new LinkedList<Map.Entry<String, Integer>>(hm.entrySet());

		// Sort the list
		Collections.sort(list, new Comparator<Map.Entry<String, Integer>>() {
			public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
				return (o1.getValue()).compareTo(o2.getValue());
			}
		});

		// put data from sorted list to hashmap
		HashMap<String, Integer> temp = new LinkedHashMap<String, Integer>();
		for (Map.Entry<String, Integer> aa : list) {
			temp.put(aa.getKey(), aa.getValue());
		}
		return temp;
	}
}

Output : 
Before Sorting Values...
{Geography=80, Social Studies=85, Biology=91, Civics=79, Math=98, Physics=95}
After Sorting Values...
{Civics=79, Geography=80, Social Studies=85, Biology=91, Physics=95, Math=98}

Synchronized HashMap

HashMap is a non-synchronized collection class. If we need to perform thread-safe operations on it then we must need to synchronize it explicitly.
Here is the example that briefs about synchronizing HashMap in java

Iterator should be used in a synchronized block even if we have synchronized the HashMap 

import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class SynchronizedMap {
	public static void main(String[] args) {
		Map<Integer, String> hmap= new HashMap<Integer, String>();
        hmap.put(2, "Anil");
        hmap.put(44, "Ajit");
        hmap.put(1, "Brad");
        hmap.put(4, "Sachin");
        hmap.put(88, "XYZ");
        Map map= Collections.synchronizedMap(hmap);
        Set set = map.entrySet();
        synchronized(map){
            Iterator i = set.iterator();
            // Display elements
            while(i.hasNext()) {
               Map.Entry me = (Map.Entry)i.next();
               System.out.print(me.getKey() + ": ");
               System.out.println(me.getValue());
            }
        }
	}
}

Output : 
1: Brad
2: Anil
4: Sachin
88: XYZ
44: Ajit

Conclusion

In this article, you learned what is a HashMap, how to create a HashMap, how to add new key-value pairs to a HashMap, how to remove keys from a HashMap, how to iterate over a HashMap, and how to synchronize a HashMap.

Thanks, Note

Thanks for spending your valuable time reading this post. Hope this post taught you something new today. Please share the post if you like it.