"Can you explain how HashMap works internally in Java?"
This is one of the most frequently asked Java interview questions at companies like Google, Amazon, and major Chinese tech companies (BAT). It tests your understanding of data structures, hashing, and performance optimization — all fundamental to writing efficient Java code.
Start by explaining the underlying data structure: an array of Node entries (buckets), where each node contains a key, value, hash, and next pointer.
Describe the hashing process: HashMap calls key.hashCode(), then applies a perturbation function (hash ^ (hash >>> 16)) to spread bits, and uses (n-1) & hash to find the bucket index.
Explain collision handling: In Java 8+, buckets use a linked list for few collisions, but convert to a red-black tree when the list exceeds 8 nodes (treeify threshold), and convert back to a list when it drops below 6.
Cover resizing: When the number of entries exceeds capacity * loadFactor (default 0.75), HashMap doubles the array size and rehashes all entries.
Mention thread safety: HashMap is not thread-safe; use ConcurrentHashMap for concurrent access.
HashMap in Java uses an array of Node buckets as its core structure. When you call put(key, value), it first computes the hash of the key using hashCode() and a perturbation function that XORs the upper 16 bits with the lower 16 bits to reduce collisions. The bucket index is calculated as (array.length - 1) & hash. If two keys land in the same bucket, they form a linked list. In Java 8, when a bucket's linked list grows beyond 8 nodes and the array length is at least 64, the list is converted to a red-black tree for O(log n) lookup instead of O(n). During a get() call, HashMap finds the bucket, then traverses the list or tree comparing both hash values and equals(). The default load factor is 0.75, meaning when 75% of buckets are occupied, the array doubles in size and all entries are rehashed. This is why it's important for keys to have well-distributed hashCode() implementations and consistent equals()/hashCode() contracts. HashMap is not synchronized — for thread-safe usage, ConcurrentHashMap uses a finer-grained locking strategy with CAS operations and synchronized blocks on individual buckets.
Always mention the Java 8 improvement from linked list to red-black tree — it shows you know modern Java.
Be ready to discuss why the default load factor is 0.75 (tradeoff between space and time complexity).
Know the difference between HashMap, Hashtable, and ConcurrentHashMap for follow-up questions.
Use HireMe AI during your interview to get real-time prompts if you forget specific thresholds like treeify at 8.
To prevent worst-case O(n) lookups when many keys hash to the same bucket. Red-black trees guarantee O(log n) search time.
They go into the same bucket. HashMap then uses equals() to distinguish them within the bucket's linked list or tree.
No. Use ConcurrentHashMap for thread-safe operations, or Collections.synchronizedMap() for a simple wrapper.
HireMe AI listens to your interview in real-time, detects questions, and generates instant answer suggestions — so you never freeze up again.
Try HireMe AI Free