Java HashMap: put, get, Iterate, and Common Patterns

A Map Stores Key-Value Pairs

A HashMap (from java.util) stores associations: each key maps to one value, and you look values up by their key in roughly constant time. Think of a dictionary - the word is the key, the definition is the value.

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

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> ages = new HashMap<>();
        ages.put("Ada", 36);
        ages.put("Boris", 29);
        ages.put("Chen", 41);

        System.out.println(ages.get("Boris"));
        System.out.println(ages);
    }
}

The two type parameters are <KeyType, ValueType>. Here keys are String and values are Integer. As with ArrayList, you typically type the variable as the Map interface and construct a HashMap.

put, get, and Overwriting

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

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> stock = new HashMap<>();
        stock.put("apples", 50);
        stock.put("apples", 75);   // same key -> overwrites the old value

        System.out.println(stock.get("apples"));  // 75
        System.out.println(stock.get("pears"));    // null - key not present
    }
}

Two things to internalize:

• A key is unique. put with an existing key replaces its value and returns the old one.
• get on a missing key returns null, not an error. Auto-unboxing that null into an int throws a NullPointerException, which is a common source of bugs.

getOrDefault Avoids the Null Trap

Rather than checking for null every time, ask for a fallback:

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

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> stock = new HashMap<>();
        stock.put("apples", 50);

        int apples = stock.getOrDefault("apples", 0);
        int pears = stock.getOrDefault("pears", 0);

        System.out.println(apples + " apples, " + pears + " pears");
    }
}

This is the cleanest way to handle "maybe present" lookups, and it leads directly to the most famous HashMap pattern.

Counting Occurrences

Counting how many times each item appears is the textbook HashMap job:

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

public class Main {
    public static void main(String[] args) {
        String text = "the cat the dog the cat";
        Map<String, Integer> counts = new HashMap<>();

        for (String word : text.split(" ")) {
            counts.put(word, counts.getOrDefault(word, 0) + 1);
        }

        System.out.println(counts);
    }
}

The pattern map.put(key, map.getOrDefault(key, 0) + 1) reads as "take the current count (or zero), add one, store it back". A tidier equivalent is counts.merge(word, 1, Integer::sum).

Checking and Removing

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

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> ages = new HashMap<>();
        ages.put("Ada", 36);
        ages.put("Boris", 29);

        System.out.println(ages.containsKey("Ada"));     // true
        System.out.println(ages.containsValue(29));      // true
        System.out.println(ages.size());                 // 2

        ages.remove("Ada");
        System.out.println(ages.containsKey("Ada"));     // false
    }
}

putIfAbsent(key, value) only writes when the key is missing - useful for lazy initialization.

Looping Over a HashMap

The most common loop walks entrySet(), giving you each key and value together:

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

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> ages = new HashMap<>();
        ages.put("Ada", 36);
        ages.put("Boris", 29);
        ages.put("Chen", 41);

        for (Map.Entry<String, Integer> entry : ages.entrySet()) {
            System.out.println(entry.getKey() + " is " + entry.getValue());
        }
    }
}

If you only need the keys or only the values:

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

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> ages = new HashMap<>();
        ages.put("Ada", 36);
        ages.put("Boris", 29);

        for (String name : ages.keySet()) {
            System.out.println(name);
        }
        for (int age : ages.values()) {
            System.out.println(age);
        }
    }
}

You can also use forEach with a lambda: ages.forEach((name, age) -> System.out.println(name + ": " + age));.

HashMap Does Not Keep Order

A HashMap makes no promise about iteration order - it is whatever the hashing produces, and it can change between runs. If you need a predictable order:

• LinkedHashMap preserves insertion order.
• TreeMap keeps keys sorted by natural ordering (or a Comparator you supply).

All three implement the Map interface, so switching is a one-line change to the constructor.

Keys Must Be Hashable

HashMap finds entries by hashing the key, so a key's hashCode() and equals() must agree. Built-in types like String and Integer already do this correctly. If you use your own class as a key, override both equals and hashCode - or two objects that are "equal" in meaning will land in different buckets and your lookups will mysteriously fail.

Next: HashSet

A HashMap answers "what value is stored under this key?". When you only care whether something is present at all - a set of unique values, with no associated data - the tool is HashSet, coming up next.