HashMap in Java

HashMap in Java is a class that implements the Map interface using a hash table. It is used to store key-value pairs and to find a value by its key very quickly, in constant time on average. HashMap allows one null key and any number of null values, and it does not keep any order. It is the most widely used map in Java. In this lesson, you will learn how to create a HashMap, use its methods, and make your own classes work as keys.

Declaration

public class HashMap<K, V> extends AbstractMap<K, V>
        implements Map<K, V>, Cloneable, Serializable

Features of HashMap

• Unique keys, any values.
• No order: iteration order depends on hash codes and can change as the map grows.
• One null key and many null values.
• Fast: put, get, remove and containsKey are O(1) on average.
• Default capacity 16, load factor 0.75: it resizes when it becomes three-quarters full.
• Not synchronized.

Constructors

Example: A Simple Phone Book

Let's see an example of the common operations.

import java.util.HashMap;
import java.util.Map;
 
public class PhoneBook {
    public static void main(String[] args) {
        Map<String, String> phones = new HashMap<>();
        phones.put("Navika", "98480-11111");
        phones.put("Srihitha", "98480-22222");
        phones.put("Advitha", "98480-33333");
 
        System.out.println("Navika: " + phones.get("Navika"));
        System.out.println("Count: " + phones.size());
 
        phones.put("Navika", "90000-44444");
        System.out.println("Navika now: " + phones.get("Navika"));
 
        System.out.println("Unknown: "
            + phones.getOrDefault("Anamaneni", "not saved"));
        phones.remove("Advitha");
        System.out.println("Has Advitha? " + phones.containsKey("Advitha"));
    }
}

Navika: 98480-11111
Count: 3
Navika now: 90000-44444
Unknown: not saved
Has Advitha? false

Explanation: put stores each name and number. Putting Navika again replaces the old number instead of adding a second entry, so the count stays 3. getOrDefault returns a fallback when the key is missing, and remove deletes a pair.

The Order Isn't Guaranteed

import java.util.HashMap;
import java.util.Map;
 
public class NoOrder {
    public static void main(String[] args) {
        Map<String, Integer> m = new HashMap<>();
        m.put("Navika", 1);
        m.put("Srihitha", 2);
        m.put("Advitha", 3);
        m.put("Anamaneni", 4);
        System.out.println(m);
    }
}

{Anamaneni=4, Navika=1, Srihitha=2, Advitha=3}

Explanation: The pairs come out in the order of their buckets, which depends on each key's hash code, not on when they were added. This order may differ between Java versions or after the map resizes, so code must never depend on it. "HashMap Internal Working" shows exactly how the bucket is chosen.

Using Your Own Class as a Key

A key class must override equals and hashCode, and should be immutable. A record does both automatically:

import java.util.HashMap;
import java.util.Map;
 
public class RecordKey {
    record Seat(int row, int number) { }
 
    public static void main(String[] args) {
        Map<Seat, String> booking = new HashMap<>();
        booking.put(new Seat(5, 12), "Navika");
        booking.put(new Seat(5, 13), "Srihitha");
 
        System.out.println(booking.get(new Seat(5, 12)));
        System.out.println(booking.containsKey(new Seat(9, 1)));
    }
}

Navika
false

Explanation: new Seat(5, 12) used in get is a different object from the one used in put, but records compare by their data, so the map finds Navika's booking.

Common Mistakes

Using a mutable object as a key and then changing it. The entry becomes unreachable.

Overriding equals but not hashCode in a key class. Lookups with an equal object fail.

Sharing a HashMap between threads without synchronization. Use ConcurrentHashMap.

Interview Corner

Practice

1. Easy: Store the prices of five fruits in a HashMap and print the price of a fruit the user asks for, or "not sold" if it's missing.
2. Harder: Create a Point(int x, int y) record and use it as a key in a map from points to place names. Check that a new Point with the same coordinates finds the place.

Key Takeaways