Java HashMap class
Java HashMap class implements the map interface by using a hash table. It inherits AbstractMap class and
implements Map interface.
Points to remember
o Java HashMap class contains values based on the key.
o Java HashMap class contains only unique keys.
o Java HashMap class may have one null key and multiple null values.
o Java HashMap class is non synchronized.
o Java HashMap class maintains no order.
o The initial default capacity of Java HashMap class is 16 with a load factor of 0.75.
Java HashMap example to add() elements
Here, we see different ways to insert elements.
1. import java.util.*;
2. class HashMap1{
3. public static void main(String args[]){
4. HashMap<Integer,String> hm=new HashMap<Integer,String>();
5. System.out.println("Initial list of elements: "+hm);
6. hm.put(100,"Amit");
7. hm.put(101,"Vijay");
8. hm.put(102,"Rahul");
9.
10. System.out.println("After invoking put() method ");
11. for(Map.Entry m:hm.entrySet()){
12. System.out.println(m.getKey()+" "+m.getValue());
13. }
14.
15. hm.putIfAbsent(103, "Gaurav");
16. System.out.println("After invoking putIfAbsent() method ");
17. for(Map.Entry m:hm.entrySet()){
18. System.out.println(m.getKey()+" "+m.getValue());
19. }
20. HashMap<Integer,String> map=new HashMap<Integer,String>();
21. map.put(104,"Ravi");
22. map.putAll(hm);
23. System.out.println("After invoking putAll() method ");
24. for(Map.Entry m:map.entrySet()){
25. System.out.println(m.getKey()+" "+m.getValue());
26. }
27. }
28. }
Initial list of elements: {}
After invoking put() method
100 Amit
101 Vijay
102 Rahul
After invoking putIfAbsent() method
100 Amit
101 Vijay
102 Rahul
103 Gaurav
After invoking putAll() method
100 Amit
101 Vijay
102 Rahul
103 Gaurav
104 Ravi
Java HashMap example to remove() elements
Here, we see different ways to remove elements.
1. import java.util.*;
2. public class HashMap2 {
3. public static void main(String args[]) {
4. HashMap<Integer,String> map=new HashMap<Integer,String>();
5. map.put(100,"Amit");
6. map.put(101,"Vijay");
7. map.put(102,"Rahul");
8. map.put(103, "Gaurav");
9. System.out.println("Initial list of elements: "+map);
10. //key-based removal
11. map.remove(100);
12. System.out.println("Updated list of elements: "+map);
13. //value-based removal
14. map.remove(101);
15. System.out.println("Updated list of elements: "+map);
16. //key-value pair based removal
17. map.remove(102, "Rahul");
18. System.out.println("Updated list of elements: "+map);
19. }
20. }
Output:
Initial list of elements: {100=Amit, 101=Vijay, 102=Rahul, 103=Gaurav}
Updated list of elements: {101=Vijay, 102=Rahul, 103=Gaurav}
Updated list of elements: {102=Rahul, 103=Gaurav}
Updated list of elements: {103=Gaurav}
Java HashMap example to replace() elements
Here, we see different ways to replace elements.
1. import java.util.*;
2. class HashMap3{
3. public static void main(String args[]){
4. HashMap<Integer,String> hm=new HashMap<Integer,String>();
5. hm.put(100,"Amit");
6. hm.put(101,"Vijay");
7. hm.put(102,"Rahul");
8. System.out.println("Initial list of elements:");
9. for(Map.Entry m:hm.entrySet())
10. {
11. System.out.println(m.getKey()+" "+m.getValue());
12. }
13. System.out.println("Updated list of elements:");
14. hm.replace(102, "Gaurav");
15. for(Map.Entry m:hm.entrySet())
16. {
17. System.out.println(m.getKey()+" "+m.getValue());
18. }
19. System.out.println("Updated list of elements:");
20. hm.replace(101, "Vijay", "Ravi");
21. for(Map.Entry m:hm.entrySet())
22. {
23. System.out.println(m.getKey()+" "+m.getValue());
24. }
25. System.out.println("Updated list of elements:");
26. hm.replaceAll((k,v) -> "Ajay");
27. for(Map.Entry m:hm.entrySet())
28. {
29. System.out.println(m.getKey()+" "+m.getValue());
30. }
31. }
32. }
Initial list of elements:
100 Amit
101 Vijay
102 Rahul
Updated list of elements:
100 Amit
101 Vijay
102 Gaurav
Updated list of elements:
100 Amit
101 Ravi
102 Gaurav
Updated list of elements:
100 Ajay
101 Ajay
102 Ajay
Program 2: Mapping Integer Values to String Keys.
// Java code to illustrate the size() method
import java.util.*;
public class Hash_Map_Demo {
public static void main(String[] args)
{
// Creating an empty HashMap
HashMap<String, Integer> hash_map = new HashMap<String, Integer>();
// Mapping int values to string keys
hash_map.put("Geeks", 10);
hash_map.put("4", 15);
hash_map.put("Geeks", 20);
hash_map.put("Welcomes", 25);
hash_map.put("You", 30);
// Displaying the HashMap
System.out.println("Initial Mappings are: " + hash_map);
// Displaying the size of the map
System.out.println("The size of the map is " + hash_map.size());
}
}
Initial Mappings are: {4=15, Geeks=20, You=30, Welcomes=25}
The size of the map is 4
HashMap putAll() Method in Java
The java.util.HashMap.putAll() is an inbuilt method of HashMap class that is used for the copy operation. The
method copies all of the elements i.e., the mappings, from one map into another.
// Java code to illustrate the putAll() method
import java.util.*;
public class Hash_Map_Demo {
public static void main(String[] args) {
// Creating an empty HashMap
HashMap<Integer, String> hash_map = new HashMap<Integer, String>();
// Mapping string values to int keys
hash_map.put(10, "Geeks");
hash_map.put(15, "4");
hash_map.put(20, "Geeks");
hash_map.put(25, "Welcomes");
hash_map.put(30, "You");
// Displaying the HashMap
System.out.println("Initial Mappings are: " + hash_map);
// Creating a new hash map and copying
HashMap<Integer, String> new_hash_map = new HashMap<Integer, String>();
new_hash_map.putAll(hash_map);
// Displaying the final HashMap
System.out.println("The new map looks like this: " + new_hash_map);
}
}
Initial Mappings are: {20=Geeks, 25=Welcomes, 10=Geeks, 30=You, 15=4}
The new map looks like this: {25=Welcomes, 10=Geeks, 20=Geeks, 30=You, 15=4}
// Java code to illustrate the putAll() method
import java.util.*;
public class Hash_Map_Demo {
public static void main(String[] args)
{
// Creating an empty HashMap
HashMap<String, Integer> hash_map = new HashMap<String, Integer>();
// Mapping int values to string keys
hash_map.put("Geeks", 10);
hash_map.put("4", 15);
hash_map.put("Geeks", 20);
hash_map.put("Welcomes", 25);
hash_map.put("You", 30);
// Displaying the HashMap
System.out.println("Initial Mappings are: " + hash_map);
// Creating a new hash map and copying
HashMap<String, Integer> new_hash_map = new HashMap<String,
Integer>();
new_hash_map.putAll(hash_map);
// Displaying the final HashMap
System.out.println("The new map looks like this: " + new_hash_map);
}
}
Initial Mappings are: {4=15, Geeks=20, You=30, Welcomes=25}
The new map looks like this: {Geeks=20, 4=15, You=30, Welcomes=25}
HashMap remove() Method in Java
The java.util.HashMap.remove() is an inbuilt method of HashMap class and is used to remove the mapping of
any particular key from the map. It basically removes the values for any particular key in the Map.
// Java code to illustrate the remove() method
import java.util.*;
public class Hash_Map_Demo {
public static void main(String[] args) {
// Creating an empty HashMap
HashMap<Integer, String> hash_map = new HashMap<Integer, String>();
// Mapping string values to int keys
hash_map.put(10, "Geeks");
hash_map.put(15, "4");
hash_map.put(20, "Geeks");
hash_map.put(25, "Welcomes");
hash_map.put(30, "You");
// Displaying the HashMap
System.out.println("Initial Mappings are: " + hash_map);
// Removing the existing key mapping
String returned_value = (String)hash_map.remove(20);
// Verifying the returned value
System.out.println("Returned value is: "+ returned_value);
// Displayin the new map
System.out.println("New map is: "+ hash_map);
}
}
Initial Mappings are: {20=Geeks, 25=Welcomes, 10=Geeks, 30=You, 15=4}
Returned value is: Geeks
New map is: {25=Welcomes, 10=Geeks, 30=You, 15=4}
Program 2: When passing a new key.
// Java code to illustrate the remove() method
import java.util.*;
public class Hash_Map_Demo {
public static void main(String[] args) {
// Creating an empty HashMap
HashMap<Integer, String> hash_map = new HashMap<Integer, String>();
// Mapping string values to int keys
hash_map.put(10, "Geeks");
hash_map.put(15, "4");
hash_map.put(20, "Geeks");
hash_map.put(25, "Welcomes");
hash_map.put(30, "You");
// Displaying the HashMap
System.out.println("Initial Mappings are: " + hash_map);
// Removing the new key mapping
String returned_value = (String)hash_map.remove(50);
// Verifying the returned value
System.out.println("Returned value is: "+ returned_value);
// Displayin the new map
System.out.println("New map is: "+ hash_map);
}
}
Initial Mappings are: {20=Geeks, 25=Welcomes, 10=Geeks, 30=You, 15=4}
Returned value is: null
New map is: {20=Geeks, 25=Welcomes, 10=Geeks, 30=You, 15=4}
Difference between HashSet and HashMap
HashSet contains only values whereas HashMap contains an entry(key and value).
Java HashMap Example: Book
1. import java.util.*;
2. class Book {
3. int id;
4. String name,author,publisher;
5. int quantity;
6. public Book(int id, String name, String author, String publisher, int quantity) {
7. this.id = id;
8. this.name = name;
9. this.author = author;
10. this.publisher = publisher;
11. this.quantity = quantity;
12. }
13. }
14. public class MapExample {
15. public static void main(String[] args) {
16. //Creating map of Books
17. Map<Integer,Book> map=new HashMap<Integer,Book>();
18. //Creating Books
19. Book b1=new Book(101,"Let us C","Yashwant Kanetkar","BPB",8);
20. Book b2=new Book(102,"Data Communications & Networking","Forouzan","Mc Graw Hill",4);
21. Book b3=new Book(103,"Operating System","Galvin","Wiley",6);
22. //Adding Books to map
23. map.put(1,b1);
24. map.put(2,b2);
25. map.put(3,b3);
26.
27. //Traversing map
28. for(Map.Entry<Integer, Book> entry:map.entrySet()){
29. int key=entry.getKey();
30. Book b=entry.getValue();
31. System.out.println(key+" Details:");
32. System.out.println(b.id+" "+b.name+" "+b.author+" "+b.publisher+" "+b.quantity);
33. }
34. }
35. }
Output:
1 Details:
101 Let us C Yashwant Kanetkar BPB 8
2 Details:
102 Data Communications & Networking Forouzan Mc Graw Hill 4
3 Details:
103 Operating System Galvin Wiley 6
Difference between HashMap and HashSet
Example of HashSet and HashMap in Java
HashSet
// Java program to demonstrate working of HashSet
import java.util.HashSet;
public class HashSetExample {
public static void main(String[] args)
{
HashSet<String> hs = new HashSet<String>();
// Adding elements to the HashSet
hs.add("geeks");
hs.add("practice");
hs.add("contribute");
;
System.out.println("Before adding duplicate values \n\n" + hs);
// Addition of duplicate elements
hs.add("geeks");
hs.add("practice");
System.out.println("\nAfter adding duplicate values \n\n" + hs);
// Addition of null values
hs.add(null);
hs.add(null);
// Displaying HashSet elements
System.out.println("\nAfter adding null values \n\n" + hs);
}
}
Output:
Before adding duplicate values
[practice, geeks, contribute]
After adding duplicate values
[practice, geeks, contribute]
After adding null values
[null, practice, geeks, contribute]
HashMap
import java.util.HashMap;
public class HashMapExample {
public static void main(String[] args)
{
/* This is how to declare HashMap */
HashMap<Integer, String> hm = new HashMap<Integer, String>();
/*Adding elements to HashMap*/
hm.put(12, "geeks");
hm.put(2, "practice");
hm.put(7, "contribute");
System.out.println("\nHashMap object output :\n\n" + hm);
// store data with duplicate key
hm.put(12, "geeks");
System.out.println("\nAfter inserting duplicate key :\n\n" + hm);
}
}
Output:
HashMap object output :
{2=practice, 7=contribute, 12=geeks}
After inserting duplicate key :
{2=practice, 7=contribute, 12=geeks}
