Map Interface Overview

The java.util.Map interface defines a structure for storing key-value pairs, where each unique key maps to exactly one value. Key characteristics include:

• Key Uniqueness: Duplicate keys are not permitted; assigning a new value to an existing key overwrites the old one.
• Null Handling: Depending on the specific implementation, a map may permit null keys and values.
• Key-Based Access: Elements are retrieved, updated, or deleted strictly using the key as the identifier.

Core Map Implementations

Java provides several classes that implement the Map interface:

• HashMap: Uses a hash table for storage. It offers constant-time performance for basic operations but does not guarantee any specific iteration order.
• TreeMap: Implemented as a red-black tree. It guarantees that keys are sorted either naturally or via a provided Comparator.
• LinkedHashMap: Extends HashMap by maintaining a doubly-linked list, which preserves either the insertion order or the access order of entries.

Usage Demonstration

The following snippet illustrates typical operations using a HashMap:

import java.util.HashMap;
import java.util.Map;

public class InventoryManager {
    public static void main(String[] args) {
        Map<String, Integer> inventoryMap = new HashMap<>();

        // Inserting elements
        inventoryMap.put("Laptop", 5);
        inventoryMap.put("Mouse", 50);
        inventoryMap.put("Keyboard", 15);

        // Determining size
        System.out.println("Total items: " + inventoryMap.size());

        // Fetching a specific value
        System.out.println("Laptop stock: " + inventoryMap.get("Laptop"));

        // Iterating through entries
        System.out.println("Current Inventory:");
        for (Map.Entry<String, Integer> item : inventoryMap.entrySet()) {
            System.out.println(item.getKey() + " -> " + item.getValue());
        }

        // Verifying key existence
        boolean hasMouse = inventoryMap.containsKey("Mouse");
        System.out.println("Contains Mouse? " + hasMouse);

        // Removing an entry
        inventoryMap.remove("Mouse");
        System.out.println("Post-removal state: " + inventoryMap);

        // Clearing the collection
        inventoryMap.clear();
        System.out.println("Cleared state: " + inventoryMap);
    }
}

Comparison of Implementations

HashMap

• Structure: Backed by an array of buckets, converting to a balanced tree (Red-Black) in case of high collisions (JDK 8+).
• Ordering: Unordered; iteration sequence is unpredictable.
• Performance: Average O(1) time complexity for put, get, and remove operations.
• Nulls: Permits one null key and multiple null values.

TreeMap

• Structure: Implemented using a Red-Black tree.
• Ordering: Sorted. Keys are arranged according to their natural ordering or a supplied Comparator.
• Performance: O(log n) time complexity for basic operations.
• Nulls: Does not allow null keys (to prevent comparison errors), but allows null values.

LinkedHashMap

• Structure: Hash table combined with a doubly-linked list running through all entries.
• Ordering: Maintains insertion-order or access-order iteration.
• Performance: Slightly slower than HashMap due to the overhead of maintaining the linked list, but still O(1) on average.
• Nulls: Permits one null key and multiple null values.

Ordering Behavior Demonstration

Observing how different implementations handle the sequence of elements reveals their core differences:

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.TreeMap;

public class MapOrderingCheck {
    public static void main(String[] args) {
        String[] keys = {"Delta", "Alpha", "Charlie", "Echo", "Bravo"};
        Double[] values = {3.0, 1.0, 4.0, 6.0, 2.0};

        Map<String, Double> hashMap = new HashMap<>();
        Map<String, Double> treeMap = new TreeMap<>();
        Map<String, Double> linkedHashMap = new LinkedHashMap<>();

        for (int i = 0; i < keys.length; i++) {
            hashMap.put(keys[i], values[i]);
            treeMap.put(keys[i], values[i]);
            linkedHashMap.put(keys[i], values[i]);
        }

        System.out.println("HashMap Output: " + hashMap);
        System.out.println("TreeMap Output: " + treeMap);
        System.out.println("LinkedHashMap Output: " + linkedHashMap);
    }
}

When executed, the outputs demonstrate distinct behaviors:

• HashMap: The output sequence appears random and is dictated by the hash codes of the keys and the internal bucket allocation.
• TreeMap: The output is alphabetically sorted (Alpha, Bravo, Charlie, Delta, Echo) based on the natural order of the String keys.
• LinkedHashMap: The output strictly matches the sequence in which the keys were originally added (Delta, Alpha, Charlie, Echo, Bravo).

It is worth noting that running the same HashMap code repeatedly might sometimes produce a seemingly consistent order. This occurs because consistent hash functions and a small dataset size can result in the same bucket distribution across runs. However, this is purely coincidental and implementation-dependent. Relying on HashMap for ordered iteration is an anti-pattern; always use TreeMap or LinkedHashMap when element sequence is a requirement.