HashMap Interview Questions and Answers for 2025

To create a thread-safe HashMap in Java, I will use the Collections.synchronizedMap method. This method returns a thread-safe map backed by the specified map. Here is an example: 

Map<String, Integer> map = Collections.synchronizedMap(new HashMap<>()); 

I can also use ConcurrentHashMap class, which is a thread-safe implementation of the Map interface. It uses fine-grained locks and does not require external synchronization. 

This question is a regular feature in Hashmap interview questions, be ready to tackle it.  

An LRU (Least Recently Used) cache can be implemented in Java using a HashMap and a doubly-linked list.

Here is an example of how I will implement an LRU cache in Java using a HashMap and a doubly-linked list: 

import java.util.HashMap; 
public class LRUCache<K, V> { 
    private final int capacity; 
    private HashMap<K, Node> map; 
    private Node head; 
    private Node tail; 
    public LRUCache(int capacity) { 
        this.capacity = capacity; 
        this.map = new HashMap<>(capacity); 
        this.head = new Node(); 
        this.tail = new Node(); 
        head.next = tail; 
        tail.prev = head; 
    }
    public V get(K key) { 
        if (!map.containsKey(key)) { 
            return null; 
        } 
        Node node = map.get(key); 
        moveToHead(node); 
        return node.value; 
    } 
    public void put(K key, V value) { 
        if (map.containsKey(key)) { 
            Node node = map.get(key); 
            node.value = value; 
            moveToHead(node); 
        } else { 
            Node node = new Node(key, value); 
            map.put(key, node); 
            addToHead(node); 
            if (map.size() > capacity) { 
                Node removed = removeTail(); 
                map.remove(removed.key); 
            } 
        } 
    } 
    private void moveToHead(Node node) { 
        removeNode(node); 
        addToHead(node); 
    } 
    private void addToHead(Node node) { 
        node.next = head.next; 
        node.prev = head; 
        head.next.prev = node; 
        head.next = node; 
    } 
    private void removeNode(Node node) { 
        node.prev.next = node.next; 
        node.next.prev = node.prev; 
    } 
    private Node removeTail() { 
        Node removed = tail.prev; 
        removeNode(removed); 
        return removed; 
    } 
    private class Node { 
        K key; 
        V value; 
        Node prev; 
        Node next;
        public Node(K key, V value) { 
            this.key = key; 
            this.value = value; 
        } 
        public Node() { 
            this(null, null); 
        } 
    } 
} 

The cache has a fixed capacity and it uses a HashMap to store the key-value pairs, with the key being the key of the pair and the value being the Node object, which contains the value and also links to the previous and next element in the doubly-linked list. 

The doubly-linked list is used to keep track of the order of elements in the cache, with the head node representing the most recently used element, and the tail node representing the least recently used element.

This is a frequently asked question in Hashmap interview questions.  

To create a HashMap with a custom comparator in Java, I will use the TreeMap class, which is an implementation of the Map interface that uses a red-black tree to store the keys. I can specify a custom comparator when creating a TreeMap to control the order in which the keys are stored and retrieved. 

Here is an example of creating a TreeMap with a custom comparator that compares User objects based on their username field: 

Comparator<User> comparator = new Comparator<User>() { 
@Override 
public int compare(User u1, User u2) { 
    return u1.getUsername().compareTo(u2.getUsername()); 
} 
}; 
Map<User, Integer> map = new TreeMap<>(comparator); 

The order of the elements in a HashMap can change during its lifetime in Java due to the way the map is implemented. A HashMap is a hash table-based implementation of the Map interface. It uses a hash function to map keys to indices in an internal array, and stores the key-value pairs in the corresponding array cells. When multiple keys hash to the same index, they are stored in a linked list at that index.

The order of the elements in a HashMap is not guaranteed to be stable over time. In particular, the order of the elements may change as the map is modified, such as when new key-value pairs are added or existing pairs are removed. The order may also change if the map is resized, which can occur if the number of key-value pairs in the map exceeds the capacity of the internal array.

If we need to maintain the insertion order of the elements in a map, we can use the LinkedHashMap class, which is a subclass of HashMap that maintains a doubly-linked list running through all of its entries. This linked list defines the iteration order, which is the order in which elements were inserted into the map.

HashMaps in Java outperform TreeMaps and LinkedHashMaps in terms of performance for the vast majority of operations, especially when dealing with huge maps.

Typical HashMap operations, including get and put, have an average-case time complexity of O(1) since they are implemented using a hash table. As a result, these procedures take roughly the same amount of time on average regardless of the size of the map. If the hash function assigns every key to the same index or if the map needs to be enlarged, the worst-case time complexity is O(n).

Alternatively, a TreeMap uses a red-black tree, which provides O(log n) time complexity for most operations. The time required for such processes grows logarithmically with the map's size.

A LinkedHashMap is a hash table that uses a linked list as its internal data structure to preserve the order in which keys and values were added. The temporal complexity is O(1) for most operations, which is comparable to that of a HashMap.

Therefore, a HashMap is typically the best option if fast access to the map's contents is required and the order of the elements is irrelevant. A LinkedHashMap is useful if you need to keep the elements in the order they were added. Using a TreeMap is a good option if you need to keep the items in some kind of order. It's important to remember that the performance of various map implementations can differ based on the operations you need to execute and the properties of the keys and values stored in the map.

To convert a HashMap to a List or Set in Java, you can use the entrySet method of the Map interface, which returns a Set view of the map that contains all of the key-value pairs in the map. I can then create a new List or Set and add the elements of the Set view to it.

Here is an example of converting a HashMap to a List of keys:

Map<String, Integer> map = new HashMap<>(); 
map.put("a", 1); 
map.put("b", 2); 
map.put("c", 3); 
List<String> keys = new ArrayList<>(); 
keys.addAll(map.keySet()); 

A must-know for anyone heading into a Hashmap interview, this question is frequently asked in Java Hashmap interview questions.  

To merge two HashMap objects in Java, you can use the putAll() method. This method is defined in the Map interface, which HashMap implements, and it allows you to add all of the key-value pairs from one map to another. 

Here is an example of how I can use the putAll() method to merge two HashMap objects: 

import java.util.HashMap; 
public class Main { 
  public static void main(String[] args) { 
HashMap<String, Integer> map1 = new HashMap<>(); 
map1.put("A", 1); 
map1.put("B", 2); 
map1.put("C", 3); 
HashMap<String, Integer> map2 = new HashMap<>(); 
map2.put("D", 4); 
map2.put("E", 5); 
map2.put("F", 6); 
// merge map2 into map1 
map1.putAll(map2); 
// print out map1 
for (String key : map1.keySet()) { 
  System.out.println(key + ": " + map1.get(key)); 
} 
  } 
} 

This code will output the following: 

It is not possible to create a HashMap object with a fixed size in Java. The HashMap class is implemented as a dynamic data structure that automatically resizes itself when the number of elements it contains exceeds its capacity.

If I want to create a map-like data structure with a fixed size, I can use the java.util.LinkedHashMap class instead. This class is a variant of HashMap that maintains a linked list of the entries in the map, in the order in which they were inserted. I can use the LinkedHashMap constructor that takes a maximum capacity as an argument to create a map with a fixed size.

To create a HashMap object in Java that automatically removes expired entries, we can use the java.util.concurrent.ConcurrentHashMap class and the java.util.concurrent.TimeUnit class.

The ConcurrentHashMap class is a thread-safe variant of HashMap that provides atomic operations for adding, removing, and updating elements. It also has a method called putIfAbsent() that allows us to add a key-value pair to the map only if the key is not already present.

The TimeUnit class is a utility class that defines a set of time units (such as seconds, minutes, and hours) and provides methods for converting between them. It has a method called toNanos() that converts a time value from a given time unit to nanoseconds.

Here is an example of how we can use the ConcurrentHashMap and TimeUnit classes to create a map that automatically removes expired entries:

It's no surprise that this one pops up often in Hashmap coding interview questions.  

For example, the input array {1, 2, 3, 1, 2, 3, 4} should produce the following output:

import java.util.HashMap; 
public class Main { 
  public static int[] removeDuplicates(int[] array) { 
HashMap<Integer, Boolean> seen = new HashMap<>(); 
int[] result = new int[array.length]; 
int count = 0; 
for (int element : array) { 
  if (!seen.containsKey(element)) { 
    result[count] = element; 
    count++; 
    seen.put(element, true); 
  } 
} 
return result; 
  } 
  public static void main(String[] args) { 
int[] array = {1, 2, 3, 1, 2, 3, 4}; 
int[] result = removeDuplicates(array); 
for (int element : result) { 
  System.out.print(element + " ");  // prints 1 2 3 4 
} 
  } 
} 

To create a HashMap object with weak keys in Java, I will use the java.util.WeakHashMap class. This class is a variant of HashMap that uses weak references for its keys.

A WeakHashMap is a type of hash map in the Java collections framework that is similar to a regular HashMap, but with an important difference: the keys in a WeakHashMap are held weakly. This means that the keys are eligible for garbage collection as soon as there are no other strong references to them. Once the key is garbage collected, its corresponding value will be automatically removed from the WeakHashMap.

The main use case for a WeakHashMap is to implement a cache. For example, if I have a large data set that I need to cache, but I don't want the cache to consume too much memory, I will use a WeakHashMap. Because the keys in the WeakHashMap are held weakly, they will be automatically removed as soon as they are no longer being used, which helps to keep the memory usage of the cache under control.

A weak reference is a special kind of reference that does not prevent an object from being garbage collected. When an object is only weakly reachable, it can be garbage collected at any time, even if the WeakHashMap object is still in use. This means that if the only reference to an object is stored in a WeakHashMap, the object may be automatically removed from the map by the garbage collector when the object is no longer needed.

To create a HashMap object with soft values in Java, you can use the java.util.SoftReference class and the java.util.HashMap class. 

A soft reference is a special kind of reference that does not prevent an object from being garbage collected when the Java heap is running low on memory. When an object is only softly reachable, it can be garbage collected at any time if the garbage collector determines that it is necessary to free up memory. 

Here is an example of how you can use the SoftReference class and the HashMap class to create a map with soft values: 

import java.lang.ref.SoftReference; 
import java.util.HashMap; 
public class Main { 
  public static void main(String[] args) { 
HashMap<String, SoftReference<Object>> map = new HashMap<>(); 
Object value = new Object(); 
map.put("A", new SoftReference<>(value)); 
value = null;  // the only reference to the value object is now stored in the map 
System.gc();  // run the garbage collector 
System.out.println(map.containsKey("A"));  // prints "true" 
System.out.println(map.get("A").get());  // may print "null" 
  } 
} 

A common question in Hashmap programming interview questions, don't miss this one.

For example, the input string "abcabcbb" should produce the following output: 3

One way to solve this problem is to use a HashMap to track the last occurrence of each character in the input string, and a sliding window to keep track of the current substring. Here is an example of how this could be done:

import java.util.HashMap; 
public class Main { 
  public static int longestSubstring(String s) { 
int maxLength = 0; 
HashMap<Character, Integer> map = new HashMap<>(); 
int start = 0; 
for (int i = 0; i < s.length(); i++) { 
  char c = s.charAt(i); 
  if (map.containsKey(c)) { 
    start = Math.max(start, map.get(c) + 1); 
  } 
  maxLength = Math.max(maxLength, i - start + 1); 
  map.put(c, i); 
} 
return maxLength; 
  } 
  public static void main(String[] args) { 
String s = "abcabcbb"; 
int length = longestSubstring(s); 
System.out.println(length);  // prints 3 
  } 
} 

To implement a HashMap with cache eviction in Java, I will use the java.util.LinkedHashMap class.

The LinkedHashMap class is a subclass of HashMap that maintains a doubly-linked list running through all of its entries. This allows me to iterate over the entries in the map in the order in which they were last accessed, from least-recently accessed to most-recently accessed.

I can use this property of LinkedHashMap to implement a cache with eviction by setting the maximum size of the cache and overriding the removeEldestEntry() method to remove the least-recently accessed entry when the size of the cache exceeds the maximum.

For example, the input array {1, 2, 3, 1, 2, 3, 3} should produce the following output: 3 

import java.util.HashMap; 
public class Main { 
  public static int mostFrequent(int[] nums) { 
HashMap<Integer, Integer> count = new HashMap<>(); 
for (int num : nums) { 
  count.put(num, count.getOrDefault(num, 0) + 1); 
} 
int maxCount = 0; 
int mostFrequent = 0; 
for (int num : count.keySet()) { 
  if (count.get(num) > maxCount) { 
    maxCount = count.get(num); 
    mostFrequent = num; 
  } 
} 
return mostFrequent; 
  } 
} 

The time complexity of this method is O(n), where n is the size of the input array. 

This question is a regular feature in interview questions on Hashmap, be ready to tackle it.  

For example, the input string "abcdabcd" should produce the following output: "abcd" 

HashSet is used when you only need to store unique elements and don't need to associate any values with them, while HashMap is used when you need to store key-value pairs and retrieve values based on their corresponding keys. However, both HashMap and HashSet use the concept of hashtables internally to implement their functionality. 

import java.util.HashSet; 
public class Main { 
  public static String uniqueCharacters(String s) { 
HashSet<Character> seen = new HashSet<>(); 
StringBuilder sb = new StringBuilder(); 
for (char c : s.toCharArray()) { 
  if (!seen.contains(c)) { 
    sb.append(c); 
    seen.add(c); 
  } 
} 
return sb.toString(); 
  } 
} 

This function uses a HashSet to store the characters that have already been seen and a StringBuilder to build up the result string. It iterates through the characters in the input string, adding each character to the result string if it has not been seen before and adding it to the HashSet so that it will not be added again. 

For example, the input array {1, 2, 3, 4, 5} and target 5 should produce the following output: 2

import java.util.HashMap; 
public class Main { 
  public static int countPairs(int[] nums, int target) { 
HashMap<Integer, Integer> count = new HashMap<>(); 
for (int num : nums) { 
  count.put(num, count.getOrDefault(num, 0) + 1); 
} 
int pairs = 0; 
for (int num : count.keySet()) { 
  if (count.containsKey(target - num)) { 
    pairs += count.get(num) * count.get(target - num); 
  } 
} 
return pairs; 
  } 
} 

This function uses a HashMap to count the frequency of each number in the input array, and then iterates through the keys in the map to find pairs of numbers that add up to the target. It increments the pairs counter by the product of the frequencies of each pair of numbers, and returns the pairs count as the result.

For example, when called with the input array {1, 2, 3, 4, 5} and target 5, the function will create a HashMap with the following entries:

{ 
  1: 1, 
  2: 1, 
  3: 1, 
  4: 1, 
  5: 1 
}  

It will then iterate through the keys in the map and find that the pairs (1, 4) and (2, 3) add up to the target 5, so it will increment the pairs counter by 1 * 1 + 1 * 1 = 2 and return 2 as the result.

This is a frequently asked question in Hashmap interview questions.

For example, the input list ["race", "car", "level", "hello", "world", "madam"] should produce the following output:

import java.util.ArrayList; 
import java.util.HashMap; 
import java.util.List; 
public class Main { 
  public static List<List<String>> palindromePairs(List<String> words) { 
HashMap<String, String> reversed = new HashMap<>(); 
for (String word : words) { 
  StringBuilder sb = new StringBuilder(word); 
  reversed.put(sb.reverse().toString(), word); 
} 
List<List<String>> pairs = new ArrayList<>(); 
for (String word : words) { 
  if (reversed.containsKey(word) && !word.equals(reversed.get(word))) { 
    List<String> pair = new ArrayList<>(); 
    pair.add(word); 
    pair.add(reversed.get(word)); 
    pairs.add(pair); 
  } 
} 
return pairs; 
  } 
} 

The time complexity of this method is O(n*k), where n is the size of the input list of words and k is the average length of the words in the input list.

The space complexity of this method is O(n*k) as well, where n is the size of the input list of words, and k is the average length of the words in the input list. The main source of space consumption is the HashMap which is used to store the reversed version of each word as the key and the original word as the value. The size of this map will be O(nk) because in the worst case where each word is unique and different with each other, all the words are stored in the map. Additionally, a list pairs is used to store all the palindrome pairs, which will also take O(n) space.

This code iterates through the list of words and uses the put() and getOrDefault() methods of the HashMap object to count the frequency of each word. The put() method adds the word to the map or updates its count if it already exists.

To implement a HashMap with a custom entry class in Java, we can define a class that represents an entry in the map, and then use this class as the type of the key-value pairs in the HashMap. 

Here is an example of how I will implement a HashMap with a custom entry class in Java: 

To implement a HashMap with a custom key and value generator in Java, I can define a class that generates the keys and values for the map, and use this class to create the HashMap object and populate it with elements. 

Here is an example of how I will implement a HashMap with a custom key and value generator in Java: 

import java.util.HashMap; 
import java.util.Random; 
public class Main { 
  static class KeyGenerator { 
private Random random = new Random(); 
public int generateKey() { 
  return random.nextInt(); 
} 
  } 
  static class ValueGenerator { 
private Random random = new Random(); 
public String generateValue() { 
  return Long.toHexString(random.nextLong()); 
} 
  } 
  public static void main(String[] args) { 
KeyGenerator keyGenerator = new KeyGenerator(); 
ValueGenerator valueGenerator = new ValueGenerator(); 
HashMap<Integer, String> map = new HashMap<>(); 
for (int i = 0; i < 10; i++) { 
  int key = keyGenerator.generateKey(); 
  String value = valueGenerator.generateValue(); 
  map.put(key, value); 
} 
System.out.println(map); 
  } 
} 

Expect to come across this popular question in Hashmap interview questions for experienced.  

To implement a HashMap with a custom key and value serializer in Java, I can define a class that knows how to serialize and deserialize the keys and values for the map and use this class to create the HashMap object and populate it with elements. 

Here is an example of how I may implement a HashMap with a custom key and value serializer in Java: 

import java.io.ByteArrayInputStream; 
import java.io.ByteArrayOutputStream; 
import java.io.IOException; 
import java.io.ObjectInputStream; 
import java.io.ObjectOutputStream; 
import java.util.HashMap; 
public class Main { 
  static class KeySerializer { 
public byte[] serialize(int key) throws IOException { 
  try (ByteArrayOutputStream baos = new ByteArrayOutputStream(); 
       ObjectOutputStream oos = new ObjectOutputStream(baos)) { 
    oos.writeInt(key); 
    return baos.toByteArray(); 
  } 
}
public int deserialize(byte[] data) throws IOException, ClassNotFoundException { 
  try (ByteArrayInputStream bais = new ByteArrayInputStream(data); 
       ObjectInputStream ois = new ObjectInputStream(bais)) { 
    return ois.readInt(); 
  } 
} 
  } 
  static class ValueSerializer { 
public byte[] serialize(String value) throws IOException { 
  try (ByteArrayOutputStream baos = new ByteArrayOutputStream(); 
       ObjectOutputStream oos = new ObjectOutputStream(baos)) { 
    oos.writeUTF(value); 
    return baos.toByteArray(); 
  } 
} 
  } 
  public static void main(String[] args) throws IOException, ClassNotFoundException { 
KeySerializer keySerializer = new KeySerializer(); 
ValueSerializer valueSerializer = new ValueSerializer(); 
HashMap<byte[], byte[]> map = new HashMap<>(); 
map.put(keySerializer.serialize(1), valueSerializer.serialize("a")); 
map.put(keySerializer.serialize(2), valueSerializer.serialize("b")); 
map.put(keySerializer.serialize(3), valueSerializer.serialize("c")); 
} 
} 

To implement a HashMap with a custom key and value factory in Java, I can define a class that knows how to create the keys and values for the map, and use this class to create the HashMap object and populate it with elements. 

Here is an example of how you might implement a HashMap with a custom key and value factory in Java: 

import java.util.HashMap; 
import java.util.function.Function; 
public class Main { 
  static class KeyFactory implements Function<Integer, String> { 
@Override 
public String apply(Integer key) { 
  return Integer.toHexString(key); 
} 
  } 
  static class ValueFactory implements Function<String, Integer> { 
@Override 
public Integer apply(String value) { 
  return value.length(); 
} 
  } 
  public static void main(String[] args) { 
KeyFactory keyFactory = new KeyFactory(); 
ValueFactory valueFactory = new ValueFactory(); 
HashMap<String, Integer> map = new HashMap<>(); 
map.computeIfAbsent(keyFactory.apply(1), valueFactory); 
map.computeIfAbsent(keyFactory.apply(2), valueFactory); 
map.computeIfAbsent(keyFactory.apply(3), valueFactory); 
System.out.println(map.get(keyFactory.apply(1)));  // prints 1 
System.out.println(map.get(keyFactory.apply(2)));  // prints 1 
System.out.println(map.get(keyFactory.apply(3)));  // prints 1 
  } 
} 

To implement a HashMap with a custom key and value transformer in Java, you can define a class that knows how to transform the keys and values for the map and use this class to create the HashMap object and populate it with elements. 

Here is an example of how I will implement a HashMap with a custom key and value transformer in Java: 

import java.util.HashMap; 
import java.util.function.Function; 
 public class Main { 
  static class KeyTransformer implements Function<Integer, String> { 
@Override 
public String apply(Integer key) { 
  return Integer.toHexString(key); 
} 
  } 
  static class ValueTransformer implements Function<String, Integer> { 
@Override 
public Integer apply(String value) { 
  return value.length(); 
} 
  }  
  public static void main(String[] args) { 
KeyTransformer keyTransformer = new KeyTransformer(); 
ValueTransformer valueTransformer = new ValueTransformer(); 
HashMap<Integer, String> map = new HashMap<>(); 
map.put(1, "a"); 
map.put(2, "b"); 
map.put(3, "c"); 
map.replaceAll((key, value) -> keyTransformer.apply(key), valueTransformer); 
System.out.println(map.get(1));  // prints 1 
System.out.println(map.get(2));  // prints 1 
System.out.println(map.get(3));  // prints 1 
  } 
} 

In this example, the KeyTransformer class implements a Function that takes an Integer key and returns a String key, and the ValueTransformer class implements a Function that takes a String value and returns an Integer value. 

The main() method creates instances of the KeyTransformer and ValueTransformer classes and uses them to transform the keys and values of the HashMap using the replaceAll() method. The final state of the HashMap is then printed to the console. 

A must-know for anyone heading into a Hashmap interview, this question is frequently asked in Java Hashmap interview questions.  

To implement a HashMap with a custom key and value filter in Java, I will define a class that knows how to filter the keys and values for the map and use this class to create the HashMap object and populate it with elements. 

Here is an example of how I will implement a HashMap with a custom key and value filter in Java: 

import java.util.HashMap; 
import java.util.function.Predicate; 
public class Main { 
  static class KeyFilter implements Predicate<Integer> { 
@Override 
public boolean test(Integer key) { 
  return key % 2 == 0; 
} 
  } 
  static class ValueFilter implements Predicate<String> { 
@Override 
public boolean test(String value) { 
  return value.length() % 2 == 0; 
} 
  } 
  public static void main(String[] args) { 
KeyFilter keyFilter = new KeyFilter(); 
ValueFilter valueFilter = new ValueFilter(); 
HashMap<Integer, String> map = new HashMap<>(); 
map.put(1, "a"); 
map.put(2, "bb"); 
map.put(3, "ccc"); 
map.entrySet().removeIf(entry -> !keyFilter.test(entry.getKey()) || !valueFilter.test(entry.getValue())); 
System.out.println(map);  // prints {2=bb} 
  } 
} 

There are several ways to handle concurrency issues in a HashMap in a high-concurrency environment in Java: 

• Use the ConcurrentHashMap class instead of the HashMap class. ConcurrentHashMap is a thread-safe implementation of Map that provides better performance in high-concurrency environments compared to HashMap. 
• Use a synchronized block or method to synchronize access to the HashMap. This will prevent multiple threads from modifying the map at the same time, but can lead to reduced performance due to the overhead of synchronization. 
• Use the Collections.synchronizedMap() method to create a synchronized wrapper around a HashMap. This will also prevent multiple threads from modifying the map at the same time, but can also lead to reduced performance due to the overhead of synchronization. 

To compare the performance of different map implementations (e.g. HashMap, TreeMap, LinkedHashMap) in Java, I will use a microbenchmarking library such as JMH (Java Microbenchmark Harness) to measure the time it takes for each map implementation to perform a set of operations.

To design a scalable and maintainable HashMap implementation in Java, I will consider the following best practices: 

• A good hash function to distribute the keys evenly across the map and reduce the likelihood of hash collisions. A good hash function should be fast, uniform, and produce different outputs for different inputs. 
• A dynamic resizing mechanism to adjust the size of the map as the number of elements in the map grows or shrinks. This can help to improve the performance of the map by keeping the number of elements per bucket within a reasonable range. 
• Linked list or tree structure to store the elements in each bucket, rather than using an array. This will allow the map to handle a larger number of elements without incurring a significant performance penalty.