HashMap In Java
In today’s discussion, we will cover Java HashMap with examples, which is intended to meet the learning needs of our learners
Java HashMap
You learned in the ArrayList chapter that arrays contain items in an ordered collection that can be accessed by index numbers (ints).
As far as Java HashMaps are concerned, Hashmap stores the items in groups of “key/value” pairs, and you can access them by an index datatype rather than using int only (e.g. String).
The key (index) of one object is used to access the value of another object.
There are two types of data it can store: String keys and Character values, or the same type, like String keys and String values.
Make a HashMap object and name it sports_players for storing String keys and String values:
import java.util.HashMap; // HashMap class is imported here
HashMap<String, String> sports_players = new HashMap<String, String>();
Make a HashMap object and name it rank_Id for storing String keys and String values:
import java.util.HashMap; // HashMap class is imported here
HashMap<Integer, Integer> rank_Id = new HashMap<Integer, Integer>();
Java HashMap Put()
There are many useful methods in the HashMap class. You can use the put() method to add items to it, for example:
Declare a HashMap object and name it sports_players for storing String keys as sports name and String values as famous player name.
import java.util.HashMap; // HashMap class is imported here
public class Main {
public static void main(String[] args) {
HashMap<String, String> sports_players = new HashMap<String, String>(); // The object of Hashmap is created heere in which key and value both are of type String.
sports_players.put("Football","Cristiano Ronaldo");
sports_players.put("Cricket","Sachin Tendulkar");
sports_players.put("Hockey","Wayne Gretzky");
sports_players.put("Baseball","Babe Ruth");
sports_players.put("Rugby","Jonah Lomu");
System.out.println(sports_players);
}
}
Similarly, we have initialize a HashTree object that stores rank as keys and Id as value:
import java.util.HashMap; // HashMap class is imported here
public class Main {
public static void main(String[] args) {
HashMap<Integer, Integer> rank_Id = new HashMap<Integer, Integer>();// Here, a HashMap object is created and named as rank_Id, whose key and value are both integers.
rank_Id.put(1,10001);
rank_Id.put(2,10002);
rank_Id.put(3,10003);
rank_Id.put(4,10004);
rank_Id.put(5,10005);
System.out.println(rank_Id);
}
}
Java HashMap Get()
When we discuss Java HashMap, the get() method and the key are used to access values in a HashMap.
import java.util.HashMap; // HashMap class is imported here
public class Main {
public static void main(String[] args) {
HashMap<String, String> it_Firms = new HashMap<String,String >();
it_Firms.put("1","Cognizant");
it_Firms.put("2","Vates-Software");
it_Firms.put("3","MantorMate");
it_Firms.put("4","Resultant");
it_Firms.put("5","Fortegrp");
// All Elements of HashMap
System.out.println(it_Firms);
// By accessing the value at key number 3
System.out.println("\nValue at key 3: "+it_Firms.get("3"));
}
}
Another Approach:
import java.util.HashMap; // HashMap class is imported here
public class Main {
public static void main(String[] args) {
HashMap<Integer,Integer> rank_Age = new HashMap<Integer,Integer>();
rank_Age.put(1,21);
rank_Age.put(2,25);
rank_Age.put(3,31);
rank_Age.put(4,41);
rank_Age.put(5,37);
// All Elements of HashMap
System.out.println(rank_Age);
// By accessing the Age at key number 2
System.out.println("\nValue at key 2: "+rank_Age.get(2));
}
}
Java HashMap Remove()
Using the remove() method, remove an item by referencing its key.
The example below shows the removal of Key (“Team 4”) valued as Cleveland Cavailers.
import java.util.HashMap; // HashMap class is imported here
public class Main {
public static void main(String[] args) {
HashMap<String,String> nba_Teams = new HashMap<String,String>();
nba_Teams.put("Team 1"," Boston Celtics");
nba_Teams.put("Team 2"," Chicago Bulls");
nba_Teams.put("Team 3"," Atlanta Hawks");
nba_Teams.put("Team 4"," Cleveland Cavaliers");
nba_Teams.put("Team 5"," Detroit Pistons");
// Here we print all Elements of the HashMap Object named as nba_Teams before removing an item
System.out.println("\nBefore Removing Value: "+nba_Teams);
// Removing Cleveland Cavaliers by using its key (Team 4)
String removed= nba_Teams.remove("Team 4");
System.out.println("\nRemoved Value is: "+removed);
// Printing all elements of HashMap after an element was removed:
System.out.println("\nAfter Removing value: "+nba_Teams);
}
}
import java.util.HashMap; // HashMap class is imported here
public class Main {
public static void main(String[] args) {
HashMap<Float,Float> person_Id_Height = new HashMap<Float,Float>();
person_Id_Height.put(10f,5.4f);
person_Id_Height.put(20f,5.6f);
person_Id_Height.put(30f,5.7f);
person_Id_Height.put(40f,6.2f);
person_Id_Height.put(50f,5.11f);
// Here we print all Elements of the HashMap Object named as person_Id_Height before the item is element
System.out.println("\nBefore Removing Value: "+person_Id_Height);
// Removing from person_Id_Height HashMap by using its key (40f)
float removed= person_Id_Height.remove(40f);
System.out.println("\nRemoved Value is: "+removed);
// Printing all elements of HashMap after an element was removed:
System.out.println("\nAfter Removing value: "+person_Id_Height);
}
}
Using the clear() method, you can remove all items of the HashMap Object:
import java.util.HashMap; // HashMap class is imported here
public class Main {
public static void main(String[] args) {
HashMap<String,String> product_code = new HashMap<String,String>();
product_code.put("Cookies","102313");
product_code.put("Biscuits","153532");
product_code.put("Snacks","632123");
product_code.put("PopCorns","361232");
product_code.put("Chocolates","734231");
// Here we print all Elements of the HashMap Object named as product_code
System.out.println("HashMap: "+product_code);
// After using .clear() method our HashMap becomes empty
product_code.clear();
// Printing all elements of HashMap after all elements were removed:
System.out.println("After clearing the HashMap we get: "+product_code);
}
}
Here we clear the entire HashMap using the clear() method:
import java.util.HashMap; // HashMap class is imported here
public class Main {
public static void main(String[] args) {
HashMap<Float,Float> results_division_ = new HashMap<Float,Float>();
results_division_.put(14f/5f,2.8f);
results_division_.put(18f/7f,2.57f);
results_division_.put(19f/4f,4.75f);
results_division_.put(11f/3f,3.66f);
// Here we print all Elements of the HashMap Object named as results_division_
System.out.println("HashMap: "+results_division_);
// After using .clear() method our HashMap becomes empty
results_division_.clear();
// Printing all elements of HashMap after all elements were removed:
System.out.println("After clearing the HashMap we get: "+results_division_);
}
}
HashMap Size
The size() method can be used to find out how many items there are in the HashMap:
import java.util.HashMap; // HashMap class is imported here
public class Main {
public static void main(String[] args) {
HashMap<String,String> rank_billionaires_name = new HashMap<String,String>();
rank_billionaires_name.put("Rank 1: "," Bernard Arnault & family");
rank_billionaires_name.put("Rank 2: "," Elon Musk");
rank_billionaires_name.put("Rank 3: "," Gautam Adani");
rank_billionaires_name.put("Rank 4: "," Jeff Bezos");
// Here we print all Elements of the HashMap Object named as rank_billionaires_name
System.out.println("HashMap: "+rank_billionaires_name);
// By using size() method we can determine the size of our HashMap
System.out.println("\nSize of HashMap: "+rank_billionaires_name.size());
}
}
import java.util.HashMap; // HashMap class is imported here
public class Main {
public static void main(String[] args) {
HashMap<Character,Character> vowels_List = new HashMap<Character,Character>();
vowels_List.put('a','A');
vowels_List.put('e','E');
vowels_List.put('i','I');
vowels_List.put('o','O');
vowels_List.put('u','U');
// Here we print all Elements of the HashMap Object named as vowels_List
System.out.println("Vowels HashMap: "+vowels_List);
// By using size() method we can determine the size of our HashMap
System.out.println("\nSize of HashMap: "+vowels_List.size());
}
}
Loop Through a HashMap
A for-each loop traverses a HashMap’s items.
Remember: If you only want the keys, use the keySet() method, and if you only want the values, use the values() method.
The following examples show how can we print all the keys of the HashMap using the keySet() method:
import java.util.HashMap; // HashMap class is imported here
public class Main {
public static void main(String[] args) {
HashMap<String, String> it_Firms = new HashMap<String,String >();
it_Firms.put("1","Cognizant");
it_Firms.put("2","Vates-Software");
it_Firms.put("3","MantorMate");
it_Firms.put("4","Resultant");
it_Firms.put("5","Fortegrp");
// Using for-each loop to traverse through the keys of HashMap object named it_Firms
for(String mrx:it_Firms.keySet()){
System.out.println(mrx);
}
}
}
import java.util.HashMap; // HashMap class is imported here
public class Main {
public static void main(String[] args) {
HashMap<Integer,Integer> odd_Even = new HashMap<Integer,Integer>();
odd_Even.put(1,2);
odd_Even.put(3,4);
odd_Even.put(5,6);
odd_Even.put(7,8);
odd_Even.put(9,10);
// Using for-each loop to print through the keys of HashMap object named odd_Even
for(Integer ample:odd_Even.keySet()){
System.out.println(ample);
}
}
}
Similarly, we can also traverse and print the values of the HashMap using the values() method:
import java.util.HashMap; // HashMap class is imported here
public class Main {
public static void main(String[] args) {
HashMap<String, String> it_Firms = new HashMap<String,String >();
it_Firms.put("1","Cognizant");
it_Firms.put("2","Vates-Software");
it_Firms.put("3","MantorMate");
it_Firms.put("4","Resultant");
it_Firms.put("5","Fortegrp");
// Using for-each loop to print the values of HashMap object named it_Firms using the values() method
for(String ample:it_Firms.values()){
System.out.println(ample);
}
}
}
We have printed the keys and values from the object named as odd_Even of the HashMap:
import java.util.HashMap; // HashMap class is imported here
public class Main {
public static void main(String[] args) {
HashMap<Integer,Integer> odd_Even = new HashMap<Integer,Integer>();
odd_Even.put(1,2);
odd_Even.put(3,4);
odd_Even.put(5,6);
odd_Even.put(7,8);
odd_Even.put(9,10);
// Using for-each loop to print all the values of HashMap object named odd_Even using the values() method
for(Integer ample:odd_Even.values()){
System.out.println(ample);
}
}
}
Likewise, We can also print both (Keys and values) at a time using the keySet() method and get() method:
import java.util.HashMap; // HashMap class is imported here
public class Main {
public static void main(String[] args) {
HashMap<String, String> it_Firms = new HashMap<String,String >();
it_Firms.put("1","Cognizant");
it_Firms.put("2","Vates-Software");
it_Firms.put("3","MantorMate");
it_Firms.put("4","Resultant");
it_Firms.put("5","Fortegrp");
// We can also access the keys and values at a time
for(String ample:it_Firms.keySet()){
System.out.println("Key: "+ample+" Value: "+it_Firms.get(ample));
}
}
}
import java.util.HashMap; // HashMap class is imported here
public class Main {
public static void main(String[] args) {
HashMap<Integer,Integer> odd_Even = new HashMap<Integer,Integer>();
odd_Even.put(1,2);
odd_Even.put(3,4);
odd_Even.put(5,6);
odd_Even.put(7,8);
odd_Even.put(9,10);
// As we did in the example above, we can print the keys and the values at a same time using th for-each loop
for(Integer mrx:odd_Even.keySet()){
System.out.println("Key Number: "+mrx+" Value: "+odd_Even.get(mrx));
}
}
}
Other Types
There are actually objects that make up the keys and values of a HashMap. Objects of type “String” and “Integer” were used in the examples above. Strings are objects in Java (not primitive types).
If you’d like to access other types, such as int, you’ll need to specify an equivalent wrapper class: Integer.
When it comes to other primitive types, use Boolean for boolean, character for character, double for double, etc.
To store Integer keys and String values, we create a HashMap object called silent_letter_words:
import java.util.HashMap;
public class Main {
public static void main(String[] args) {
HashMap <Integer,String> silent_letter_words=new HashMap<Integer,String>();
silent_letter_words.put(1,"Bomb");
silent_letter_words.put(2,"Knife");
silent_letter_words.put(3,"Kitchen");
silent_letter_words.put(4,"Wrap");
silent_letter_words.put(5,"Cupboard");
for(int mrx:silent_letter_words.keySet()){
System.out.println("Number "+mrx+" ="+" Word: "+silent_letter_words.get(mrx));
}
}
}
Furthermore, we can also print the name of persons as keys and their body weights as value as shown below:
import java.util.HashMap;
public class Main {
public static void main(String[] args) {
HashMap <String,Double> person_Weight=new HashMap<String,Double>();
person_Weight.put("Joseph",56.8d);
person_Weight.put("Diana",64.2d);
person_Weight.put("Emma",44.1d);
person_Weight.put("Sophia",77.4d);
person_Weight.put("Noah",58.9d);
for(String ample:person_Weight.keySet()){
System.out.println(ample+" have "+"Weight= "+person_Weight.get(ample)+" kgs");
}
}
}
