Comprehensive Java HashMap Interview Questions and Answers

Introduction

HashMap is a frequently asked topic in Java interviews because it touches on many core concepts such as data structures, hashing, concurrency, and performance. This article gathers a large set of interview questions (more than 30) and provides concise answers.

Why Interviewers Like HashMap

High usage frequency in real projects.

Tests fundamental Java knowledge.

Opens discussion on thread‑safety and concurrency.

Widely used by major tech companies.

Interview Question List (25+ Questions)

What is the underlying data structure of HashMap?

Describe HashMap’s working principle.

How does HashMap handle identical hashCodes?

How is the hash function designed?

How many ways can you iterate over a HashMap?

Why does HashMap xor the high 16 bits with the low 16 bits?

How is the table capacity determined?

Explain the loadFactor parameter.

Describe the put() process.

When does a linked list become a red‑black tree?

What is the initial capacity when creating new HashMap(18)?

Explain the resize (expansion) process.

How does get() work?

Why is the length of HashMap a power of two?

Differences among HashMap, LinkedHashMap, and TreeMap.

What is fail‑fast?

Differences between HashMap and Hashtable.

Is HashMap thread‑safe?

How to avoid HashMap’s thread‑safety issues?

Differences between HashMap and ConcurrentHashMap.

Why is ConcurrentHashMap faster than Hashtable?

Lock mechanism of ConcurrentHashMap (JDK 7 vs JDK 8).

Why does JDK 8 replace ReentrantLock with synchronized in ConcurrentHashMap?

Brief introduction to ConcurrentHashMap.

What is the concurrency level of ConcurrentHashMap?

Key Answers (Selected Highlights)

1. Underlying Data Structure

HashMap uses an array of buckets combined with singly linked lists; since JDK 8 it also uses red‑black trees when a bucket’s chain length exceeds a threshold.

2. Working Principle

When put(key, value) is called, the key’s hashCode() is computed, then a secondary hash (xor of high and low 16 bits) determines the bucket index. The entry is stored in the bucket; get() recomputes the hash, locates the bucket, and searches the chain or tree using equals().

4. Hash Function Design

The hash function mixes the high 16 bits with the low 16 bits via XOR to reduce collisions and to keep the operation fast using bitwise operators.

5. Iteration Methods

Iterator

for‑each loop (Java 8)

foreach over keySet() foreach over

entrySet()

7. Table Capacity Determination

The default capacity is 16. The capacity is always a power of two; it can be set via the constructor or grows automatically when the size exceeds capacity * loadFactor.

8. Load Factor

Default load factor is 0.75. When the number of entries exceeds capacity × loadFactor, the table is resized.

9. put() Process

In JDK 7 the internal class is Entry; in JDK 8 it is renamed to Node. The steps are: (1) compute hash, (2) locate bucket, (3) if empty insert, (4) if collision, traverse chain or tree, (5) if chain length ≥ 8 and bucket count ≥ 64, convert to red‑black tree, (6) if load factor exceeded, trigger resize.

static final int tableSizeFor(int cap) {
    int n = cap - 1;
    n |= n >>> 1;
    n |= n >>> 2;
    n |= n >>> 4;
    n |= n >>> 8;
    n |= n >>> 16;
    return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}

12. Linked List → Red‑Black Tree

When a bucket’s chain length reaches 8, converting to a red‑black tree reduces the average lookup cost from O(n) to O(log n).

13. Initial Capacity of new HashMap(18)

The actual capacity becomes the next power of two, i.e., 32.

14. Resize Process

A new array double the size of the old one is allocated; each existing node is rehashed to either the same index or index + oldCapacity.

22. Fail‑Fast

Iterators detect structural modifications (add, remove, clear) made by other threads and throw ConcurrentModificationException. Using concurrent collections from java.util.concurrent avoids this problem.

23. HashMap vs Hashtable

HashMap is not thread‑safe; Hashtable is synchronized.

HashMap allows one null key and multiple null values; Hashtable allows neither.

Default initial capacity: 16 for HashMap, 11 for Hashtable.

24. Thread Safety of HashMap

HashMap is not thread‑safe. In multithreaded scenarios it can cause data loss, infinite loops, or overwritten entries.

25‑26. Avoiding Thread‑Safety Issues

Wrap with Collections.synchronizedMap.

Use ConcurrentHashMap for high concurrency.

27‑28. ConcurrentHashMap Advantages

JDK 7 uses segment locks ( ReentrantLock + Segment); JDK 8 switches to CAS + synchronized + Node, reducing lock granularity to individual nodes and improving throughput.

29. Synchronized vs ReentrantLock in JDK 8

Synchronized benefits from JVM optimizations, lower memory overhead, and finer‑grained locking compared to explicit ReentrantLock.

Conclusion

The article compiles a comprehensive set of HashMap interview questions and detailed answers, covering its internal structure, hashing strategy, collision handling, resizing, thread‑safety, and differences from related map implementations, providing a solid preparation resource for Java developers.