Search for a command to run...
Learner, Love to make things simple, Full Stack Developer, StackOverflower, Passionate about using machine learning, deep learning and AI
No comments yet. Be the first to comment.
Spring Boot tutorials, java and spring cloud tutorials where we can cover other parts like microservices, etc.
Enums in Java are an invaluable resource for simplifying code, enhancing readability, and maintaining type safety in your applications. By leveraging enums alongside the Strategy Pattern, you can reduce complex conditional logic like if-else and swit...
Move beyond traditional RESTful thinking. Learn how to design APIs specifically for MCP (Model Context Protocol) servers. This guide covers the shift in mindset, a practical OpenAPI 3.1 example, and a Spring Boot implementation to make your services ...
Extending Kestra to Every Corner of Your Data Stack. Introduction: The Power of Plugins Imagine you're a master chef. You don't just have one knife - you have specialized tools for every task: a paring knife for delicate work, a chef's knife for chop...
Mastering Complex Orchestration Scenarios. Introduction: The Orchestrator's Toolkit Imagine you're conducting a symphony. You don't just wave your baton - you cue sections, adjust tempo, handle surprises, and ensure harmony. That's what advanced work...
From Data Extraction to Loading - A Practical Guide Introduction: Why ETL Still Matters in the Modern Data Stack Remember when data engineering was "extract, transform, load"? Some say ETL is dead, replaced by ELT, reverse ETL, and data mesh. But her...
Building Blocks of Declarative Orchestration. Introduction: The Power of Simplicity Imagine trying to build a house without understanding bricks, beams, and blueprints. That's what using an orchestration tool without understanding its core concepts f...
In Java interviews, questions about the Map interface and its implementations like HashMap, ConcurrentHashMap, SynchronizedMap, and TreeMap often test both theoretical knowledge and practical problem-solving skills. This guide provides a mix of tricky and scenario-based questions with answers to help you ace your interview.
equals() method, not just the hash code.Answer:
Null Key: HashMap allows a single null key and stores it at index 0 of the bucket array.
Null Values: Multiple null values are allowed.
Answer:
SynchronizedMap synchronizes all methods, which leads to a performance bottleneck.
ConcurrentHashMap uses a lock-striping mechanism, allowing concurrent reads and writes to different buckets, improving performance.
Answer:
Null keys are not allowed in TreeMap because it uses natural ordering or a comparator, and null keys can't be compared.
Null values are allowed.
Answer:
Best Case: O(1)O(1)O(1) if there are no collisions.
Worst Case: O(logn)O(\log n)O(logn) in Java 8 and later (when buckets use balanced trees).
Comparator.ConcurrentModificationException. For better performance, consider using ConcurrentHashMap.Answer:
When the load factor exceeds the threshold, HashMap resizes by doubling the capacity.
During resizing, the entries are rehashed and redistributed into the new bucket array.
Answer:
Fail-Fast: Iterators on HashMap, SynchronizedMap, etc., throw a ConcurrentModificationException if the map is structurally modified during iteration.
Fail-Safe: Iterators on ConcurrentHashMap work on a copy of the map and do not throw exceptions during concurrent modifications.
Answer:
Initial capacity reduces the need for resizing if the number of elements is predictable.
Load factor balances memory usage and performance. A higher load factor uses less memory but increases collision probability.
import java.util.concurrent.ConcurrentHashMap;
public class ConcurrentHashMapExample {
public static void main(String[] args) {
ConcurrentHashMap<String, String> map = new ConcurrentHashMap<>();
map.put("1", "Value1");
map.put("2", "Value2");
// Concurrently modify map
map.putIfAbsent("3", "Value3");
map.compute("2", (key, val) -> val + "_Modified");
System.out.println(map);
}
}
import java.util.*;
public class TreeMapExample {
public static void main(String[] args) {
TreeMap<Integer, String> treeMap = new TreeMap<>(Comparator.reverseOrder());
treeMap.put(1, "One");
treeMap.put(2, "Two");
treeMap.put(3, "Three");
System.out.println(treeMap); // Prints in descending order
}
}
Answer:
Use the entrySet() method to create a stream of Map.Entry<K, V> and apply filters.
Example:
Map<String, Integer> map = Map.of("A", 10, "B", 20, "C", 30);
Map<String, Integer> filteredMap = map.entrySet().stream()
.filter(entry -> entry.getValue() > 15)
.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
System.out.println(filteredMap); // Output: {B=20, C=30}
Answer:
Convert the entrySet to a stream, sort it using a comparator, and collect it back into a new map.
Example:
Map<String, Integer> map = Map.of("A", 30, "B", 10, "C", 20);
Map<String, Integer> sortedMap = map.entrySet().stream()
.sorted(Map.Entry.comparingByValue())
.collect(Collectors.toMap(
Map.Entry::getKey,
Map.Entry::getValue,
(e1, e2) -> e1,
LinkedHashMap::new));
System.out.println(sortedMap); // Output: {B=10, C=20, A=30}
Answer:
Use Collectors.toMap() to transform a list into a map.
Example:
List<String> names = List.of("Alice", "Bob", "Charlie");
Map<String, Integer> nameLengthMap = names.stream()
.collect(Collectors.toMap(name -> name, name -> name.length()));
System.out.println(nameLengthMap); // Output: {Alice=5, Bob=3, Charlie=7}
Answer:
A DuplicateKeyException is thrown unless a merge function is specified.
Example:
List<String> names = List.of("Alice", "Bob", "Alice");
Map<String, Integer> nameCount = names.stream()
.collect(Collectors.toMap(
name -> name,
name -> 1,
Integer::sum)); // Merges duplicate keys
System.out.println(nameCount); // Output: {Alice=2, Bob=1}
Answer:
Use Collectors.groupingBy() to group elements based on a classifier function.
Example:
List<String> names = List.of("Alice", "Bob", "Charlie", "Anna");
Map<Character, List<String>> groupedByInitial = names.stream()
.collect(Collectors.groupingBy(name -> name.charAt(0)));
System.out.println(groupedByInitial); // Output: {A=[Alice, Anna], B=[Bob], C=[Charlie]}
Solution:
Map<String, Double> products = Map.of("Laptop", 800.0, "Mouse", 20.0, "Keyboard", 100.0);
Map<String, Double> discountedProducts = products.entrySet().stream()
.map(entry -> entry.getValue() > 50
? new AbstractMap.SimpleEntry<>(entry.getKey(), entry.getValue() * 0.9)
: entry)
.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
System.out.println(discountedProducts); // Output: {Laptop=720.0, Mouse=20.0, Keyboard=90.0}
Solution:
Map<String, Integer> map1 = Map.of("A", 10, "B", 20, "C", 30);
Map<String, Integer> map2 = Map.of("B", 15, "C", 25, "D", 35);
Map<String, Integer> combinedMap = Stream.concat(map1.entrySet().stream(), map2.entrySet().stream())
.collect(Collectors.toMap(
Map.Entry::getKey,
Map.Entry::getValue,
Integer::sum));
System.out.println(combinedMap); // Output: {A=10, B=35, C=55, D=35}
Solution:
Map<String, Integer> map = Map.of("A", 10, "B", 20, "C", 30);
List<String> list = map.entrySet().stream()
.map(entry -> entry.getKey() + "=" + entry.getValue())
.collect(Collectors.toList());
System.out.println(list); // Output: [A=10, B=20, C=30]
Solution:
Map<String, Integer> scores = Map.of("Alice", 85, "Bob", 65, "Charlie", 95);
Map<Boolean, Map<String, Integer>> partitioned = scores.entrySet().stream()
.collect(Collectors.partitioningBy(
entry -> entry.getValue() >= 70,
Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)));
System.out.println(partitioned);
// Output: {true={Alice=85, Charlie=95}, false={Bob=65}}
Using Maps with Streams provides a concise and elegant way to perform operations that would otherwise require verbose loops. The examples and questions above should prepare you to confidently discuss and demonstrate your knowledge of Maps and Streams in any interview.
More such articles:
https://www.youtube.com/@maheshwarligade