3.6. HashMap¶

Java also provides us a structure to store data as key/value pairs. Java calls these objects hashmaps (or maps, more generally), and they are provided by the HashMap class.

Considering the gradebook example, we can improve our program using a map. We’ll store the students’ grades along with their names in the same data structure. The names will be the keys, and the grades will be the values.

As with the other collection structures, in Java we must specify the types of the objects we’ll be storing when we declare a variable or parameter to be a map. This means specifying both key and value data types, which are allowed to be different types for a given map.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

package org.launchcode.java.demos.collections;

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

public class HashMapGradebook {

   public static void main(String[] args) {

      HashMap<String, Double> students = new HashMap<>();
      Scanner input = new Scanner(System.in);
      String newStudent;

      System.out.println("Enter your students (or ENTER to finish):");

      // Get student names and grades
      do {

         System.out.print("Student: ");
         newStudent = input.nextLine();

         if (!newStudent.equals("")) {
            System.out.print("Grade: ");
            Double newGrade = input.nextDouble();
            students.put(newStudent, newGrade);

            // Read in the newline before looping back
            input.nextLine();
         }

      } while(!newStudent.equals(""));

      // Print class roster
      System.out.println("\nClass roster:");
      double sum = 0.0;

      for (Map.Entry<String, Double> student : students.entrySet()) {
         System.out.println(student.getKey() + " (" + student.getValue() + ")");
         sum += student.getValue();
      }

      double avg = sum / students.size();
      System.out.println("Average grade: " + avg);
   }
}

Notice how a HashMap called students is declared on line 11:

11

HashMap<String, Double> students = new HashMap<>();

Here, <String, Double> defines the data types for this map’s <key, value> pairs. Like the ArrayList, when we call the HashMap constructor on the right side of the assignment, we don’t need to specify type.

We can add a new item with a .put() method, specifying both key and value:

26

students.put(newStudent, newGrade);

And while we don’t do so in this example, we may also access HashMap elements using the get method. If we had a key/value pair of "jesse"/4.0 in the students map, we could access the grade with:

Double jesseGrade = students.get("jesse");

Variables may be used to access elements:

1
2

String name = "jesse";
Double jesseGrade = students.get(name);

Looping through a map is slightly more complex than it is for ordered lists. Let’s look at the for-each loop from this example:

38
39
40
41

for (Map.Entry<String, Double> student : students.entrySet()) {
   System.out.println(student.getKey() + " (" + student.getValue() + ")");
   sum += student.getValue();
}

The iterator variable, student, is of type Map.Entry<String, Double>. The class Map.Entry is specifically constructed to be used in this fashion, to represent key/value pairs within HashMaps. Each Map.Entry object has a getKey method and a getValue method, which represent (surprisingly enough!), the key and value of the map item.

If you only need to access the key of each item in a map, you can construct a simpler loop:

1
2
3

for (String student : students.keySet()) {
   System.out.println(student);
}

A similar structure applies if you only need the values, using students.values():

1
2
3

for (double grade : students.values()) {
   System.out.println(grade);
}

1
2
3
4
5
6
7
8
9

HashMap<String, Integer> moons = new HashMap<>();
moons.put("Mercury", 0);
moons.put("Venus", 0);
moons.put("Earth", 1);
moons.put("Mars", 2);
moons.put("Jupiter", 79);
moons.put("Saturn", 82);
moons.put("Uranus", 27);
moons.put("Neptune", 14);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

moons = {
   "Mercury" = 0,
   "Venus" = 0,
   "Earth" = 1,
   "Mars" = 2,
   "Jupiter" = 79,
   "Saturn" = 82,
   "Uranus" = 27,
   "Neptune" = 14
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

moons = {
   "Mercury" = 0,
   "Venus" = 0,
   "Earth" = 1,
   "Mars" = 2,
   "Jupiter" = 79,
   "Saturn" = 82,
   "Uranus" = 27,
   "Neptune" = 14
}