Exploring Map in Java: Your Ultimate Core Java Interview Guide - Part 2

Map Implementations in Java

Java provides several implementations of the Map interface, each with its own characteristics and use cases:

• HashTable: Provides thread-safe operations but is considered legacy and not commonly used due to performance issues.
• HashMap: Offers fast key-value retrieval with no ordering guarantees. It allows one null key and multiple null values.
• LinkedHashMap: Maintains insertion order, making it suitable for scenarios where order matters. It does not allow null keys.
• TreeMap: Sorts key-value pairs based on their natural order or a custom comparator. It does not allow null keys.

Key Features of Java Map:

• Efficient Key-Value Mapping: Maps enable fast retrieval of values based on their associated keys, providing efficient data access.
• Unique Keys: Each key in a Map must be unique, ensuring that no duplicate keys are allowed. Adding a duplicate key replaces the existing key-value pair.
• Iterable Structure: Maps offer methods to iterate over keys, values, or key-value pairs, facilitating easy traversal and manipulation of data.

Internal Behaviour of HashMap

• Hashing: A hash function is used to generate a hash code for each key, determining the index of the bucket where the key-value pair will be stored.
• Collision Resolution: Collisions occur when multiple keys hash to the same bucket. HashMap uses chaining to handle collisions by maintaining a linked list of key-value pairs in each bucket.
• Resizing: As the number of key-value pairs grows, HashMap may resize its internal array of buckets to maintain performance. This involves rehashing all key-value pairs into a new array.
• Retrieval: To retrieve a value, HashMap calculates the hash code of the key and uses it to locate the appropriate bucket. It then searches the linked list in that bucket for the key and returns the corresponding value.

Concurrent Collections for Maps in Java

In Java, concurrent collections offer thread-safe alternatives to their non-concurrent counterparts, providing efficient and scalable solutions for concurrent programming. One of the key motivations behind using concurrent collections is to address the limitations of legacy thread-safe collections, such as Hashtable, which are not as performant or flexible for modern multithreaded applications.

Why Concurrent Collections?

Legacy Collections: Hashtable was among the first collections introduced in Java and provided thread safety by synchronising all methods, ensuring that only one thread could access the collection at a time. However, this global locking mechanism led to performance bottlenecks and limited scalability, making it less suitable for modern applications.

ConcurrentHashMap: With the introduction of Java 1.5, ConcurrentHashMap was introduced to provide efficient thread safety without sacrificing performance. ConcurrentHashMap uses a fine-grained locking mechanism that allows multiple threads to access different segments of the map concurrently, minimizing contention and improving overall performance.

Performance of ConcurrentHashMap

ConcurrentHashMap offers high performance compared to Hashtable due to its efficient locking strategy:

• Fine-Grained Locking: ConcurrentHashMap divides the map into multiple segments, and each segment is independently locked. By default, ConcurrentHashMap has 16 segments, allowing concurrent access to different parts of the map without contention.
• Concurrency Level: The concurrency level determines the number of threads that can simultaneously modify the map. By default, the concurrency level is 16, and each thread can lock 2 segments at a time. This fine-grained locking ensures that threads can access different segments concurrently, improving overall performance and scalability.

Commonly Used Methods of Java Map:

1. put(K key, V value): Adds a key-value pair to the map. If the key already exists, the previous value associated with the key is replaced.

Map<String, Integer> map = new HashMap<>();
map.put("apple", 10);
map.put("banana", 5);        

2. get(Object key): Retrieves the value associated with the specified key.

int appleCount = map.get("apple"); // Retrieves the value associated with the key "apple"        

3. containsKey(Object key): Checks if the map contains the specified key.

boolean containsKey = map.containsKey("apple");        

4. containsValue(Object value): Checks if the map contains the specified value.

boolean containsValue = map.containsValue(10);        

5. size(): Returns the number of key-value mappings in the map.

int size = map.size();        

6. remove(Object key): Removes the key-value pair associated with the specified key from the map.

map.remove("apple");        

7. keySet(): Returns a Set view of the keys contained in the map.

Set<String> keys = map.keySet();        

8. values(): Returns a Collection view of the values contained in the map.

Collection<Integer> values = map.values();        

9. entrySet(): Returns a Set view of the key-value mappings contained in the map.

Set<Map.Entry<String, Integer>> entrySet = map.entrySet();        

10. clear(): Removes all key-value pairs from the map.

map.clear();        

11. getOrDefault(Object key, V defaultValue): Retrieves the value associated with the specified key, or a default value if the key is not present in the map.

getOrDefault(Object key, V defaultValue)

// Retrieves the value associated with the specified key, or a default value if the key is not present in the map.        

Conclusion:

Java Map is a fundamental data structure that offers efficient key-value mapping, making it indispensable in various Java applications. By mastering its key features and commonly used methods, developers can effectively utilize maps to solve a wide range of programming problems and excel in Java interviews.