Java Map Interface Explained: HashMap, LinkedHashMap, and TreeMap

🔍 What Is It?

Map Interface

java.util.Map (does NOT extend Collection):

• →put(K key, V value) — add or replace entry
• →get(Object key) — retrieve by key (returns null if missing)
• →getOrDefault(Object key, V defaultValue) — safe get
• →containsKey(Object key) — O(1) for HashMap
• →remove(Object key) — remove entry
• →keySet() — Set of all keys
• →values() — Collection of all values
• →entrySet() — Set<Map.Entry<K,V>> for iterating pairs
• →putIfAbsent(K key, V value) — only puts if key not present
• →computeIfAbsent(K key, Function) — compute value if absent
• →merge(K key, V value, BiFunction) — merge with existing value

Key Implementations:

• →HashMap — hash table; O(1) average; no ordering
• →LinkedHashMap — HashMap + insertion order; O(1); useful for LRU cache
• →TreeMap — Red-Black tree; O(log n); keys always sorted
• →ConcurrentHashMap — thread-safe HashMap; fine-grained locking
• →EnumMap — specialized for enum keys; array-backed; very fast
• →Map.of() — immutable map (Java 9+); max 10 entries
• →Map.copyOf() — immutable copy of existing map

🎯 Why Do We Need It?

Maps are the most versatile data structure in Java:

• →Fast lookup — O(1) find by key (vs O(n) for List)
• →Grouping — group orders by customer, products by category
• →Caching — store computed results keyed by input
• →Configuration — property name to value
• →Counting — word frequency, event counts
• →Index — build an in-memory index for fast search

🏗️ What Happens in Real Projects?

Maps appear in virtually every Java service:

// Cache / lookup table
Map<String, User> userCache = new HashMap<>();
User user = userCache.computeIfAbsent(userId, id -> userRepo.findById(id));

// Grouping (replaced by Collectors.groupingBy in streams)
Map<String, List<Order>> ordersByCustomer = orders.stream()
    .collect(Collectors.groupingBy(Order::getCustomerId));

// Counting
Map<String, Long> countByStatus = orders.stream()
    .collect(Collectors.groupingBy(
        o -> o.getStatus().name(),
        Collectors.counting()
    ));

⚙️ How It Works

HashMap Internals:

• →Array of "buckets" (linked lists or trees)
• →put(key, value): compute hashCode, find bucket, check for existing key with equals(), store
• →get(key): compute hashCode, find bucket, find entry with equals()
• →Java 8+: buckets with 8+ entries convert to balanced trees (O(log n) worst case)
• →Default initial capacity: 16; load factor: 0.75 (resize when 75% full)
• →Resizing doubles the array and rehashes all entries — O(n) operation

Good hash function distributes keys evenly across buckets. Poor hash functions (many collisions) degrade HashMap to O(n).

💻 Example

Map Patterns Every Developer Uses — The Map operations and patterns you will use in every enterprise project.

// Creating maps
Map<String, Integer> scores = new HashMap<>();
Map<String, String> config = Map.of("host", "localhost", "port", "8080");  // immutable

// Basic operations
scores.put("Alice", 95);
scores.put("Bob", 87);
scores.put("Alice", 98);  // replaces 95 with 98
int aliceScore = scores.get("Alice");  // 98
int missing = scores.getOrDefault("Charlie", 0);  // 0 (safe)
scores.remove("Bob");

// Modern Map methods (Java 8+)
// putIfAbsent — only adds if key not present
scores.putIfAbsent("Dave", 75);

// computeIfAbsent — compute and store if absent (great for caching)
Map<String, List<String>> groups = new HashMap<>();
groups.computeIfAbsent("admin", k -> new ArrayList<>()).add("alice");
groups.computeIfAbsent("admin", k -> new ArrayList<>()).add("bob");
// groups = {admin: [alice, bob]}

// merge — combine with existing value
Map<String, Integer> wordCount = new HashMap<>();
String[] words = {"apple", "banana", "apple", "cherry", "banana", "apple"};
for (String word : words) {
    wordCount.merge(word, 1, Integer::sum);
    // if absent: put(word, 1); if present: put(word, existing + 1)
}
// {apple=3, banana=2, cherry=1}

// Iteration
for (Map.Entry<String, Integer> entry : scores.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}
scores.forEach((k, v) -> System.out.println(k + ": " + v));

🤔 Common Confusions

🚨 Common Production Issues

✅ Best Practices

🏛️ Architect's Note

💬 Frequently Asked Questions

🎯 Key Takeaways

🔗 Related Topics

🎯 Practice this topic in interviews

↗ Where this topic fits