Java HashMap

Java HashMap

A HashMap stores items in key/value pairs, where each key maps to a specific value.

It is part of the java.util package and implements the Map interface.

Instead of accessing elements by an index (like with ArrayList), you use a key to retrieve its associated value.

A HashMap can store many different combinations, such as:

• String keys and Integer values
• String keys and String values

Create a HashMap

Create a HashMap object called capitalCities that will store String keys and String values:

import java.util.HashMap; // Import the HashMap class

HashMap<String, String> capitalCities = new HashMap<>();

Now you can use methods like put() to add key/value pairs, get() to retrieve a value by key, and remove() to delete an entry - all by using keys instead of index numbers.

Add Items

To add items to a HashMap, use the put() method:

// Import the HashMap class
import java.util.HashMap;

public class Main {
  public static void main(String[] args) {
    // Create a HashMap object called capitalCities
    HashMap<String, String> capitalCities = new HashMap<String, String>();

    // Add keys and values (Country, City)
    capitalCities.put("England", "London");
    capitalCities.put("India", "New Dehli");
    capitalCities.put("Austria", "Wien");
    capitalCities.put("Norway", "Oslo");
    capitalCities.put("Norway", "Oslo"); // Duplicate
    capitalCities.put("USA", "Washington DC");

    System.out.println(capitalCities);
  }
}

Note: In the example above, if the same key (like "Norway") is added more than once, the latest value will overwrite the previous one, because keys in a HashMap must be unique.

Access an Item

To access a value in the HashMap, use the get() method and refer to its key:

capitalCities.get("England");

Remove an Item

To remove an item, use the remove() method and refer to the key:

capitalCities.remove("England");

To remove all items, use the clear() method:

capitalCities.clear();

HashMap Size

To find out how many items there are, use the size() method:

capitalCities.size();

Note: The size only counts unique keys. If a key is added more than once, only the latest value is kept.

Loop Through a HashMap

Loop through the items of a HashMap with a for-each loop.

Note: Use the keySet() method if you only want the keys, and use the values() method if you only want the values:

// Print keys
for (String i : capitalCities.keySet()) {
  System.out.println(i);
}

// Print values
for (String i : capitalCities.values()) {
  System.out.println(i);
}

// Print keys and values
for (String i : capitalCities.keySet()) {
  System.out.println("key: " + i + " value: " + capitalCities.get(i));
}

Other Types

Keys and values in a HashMap are actually objects. In the examples above, we used objects of type "String". Remember that a String in Java is an object (not a primitive type). To use other types, such as int, you must specify an equivalent wrapper class: Integer. For other primitive types, use: Boolean for boolean, Character for char, Double for double, etc:

// Import the HashMap class
import java.util.HashMap;

public class Main {
  public static void main(String[] args) {

    // Create a HashMap object called people
    HashMap<String, Integer> people = new HashMap<String, Integer>();

    // Add keys and values (Name, Age)
    people.put("John", 32);
    people.put("Steve", 30);
    people.put("Angie", 33);

    for (String i : people.keySet()) {
      System.out.println("key: " + i + " value: " + people.get(i));
    }
  }
}

When Order Matters

In the next chapter, you will learn about TreeMap, which stores key/value pairs in sorted order by key.

The var Keyword

From Java 10, you can use the var keyword to declare a HashMap variable without writing the type twice. The compiler figures out the type from the value you assign.

This makes code shorter, but many developers still use the full type for clarity. Since var is valid Java, you may see it in other code, so it's good to know that it exists:

// Without var
HashMap<String, String> capitalCities = new HashMap<String, String>();

// With var
var capitalCities = new HashMap<String, String>();

The Map Interface

Note: Sometimes you will see both Map and HashMap in Java code, like this:

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

Map<String, String> capitalCities = new HashMap<>();

This means the variable (capitalCities) is declared as a Map (the interface), but it stores a HashMap object (the actual map). Since HashMap implements the Map interface, this is possible.

It works the same way, but some developers prefer this style because it gives them more flexibility to change the type later.