Java Map Interface

import java.util.*;

// HashMap  — fastest, no guaranteed order
Map<String, Integer> hashMap       = new HashMap<>();

// LinkedHashMap — maintains insertion order
Map<String, Integer> linkedHashMap = new LinkedHashMap<>();

// TreeMap — sorted by key (natural order or custom Comparator)
Map<String, Integer> treeMap       = new TreeMap<>();

// Hashtable — legacy, thread-safe (avoid in new code)
Map<String, Integer> hashtable     = new Hashtable<>();

// Java 9+ — immutable Map of up to 10 entries
Map<String, Integer> immutable     = Map.of("Java", 1, "Python", 2, "Kotlin", 3);

// Java 9+ — immutable Map via Map.ofEntries (for more entries)
Map<String, Integer> large = Map.ofEntries(
    Map.entry("One",   1),
    Map.entry("Two",   2),
    Map.entry("Three", 3)
);

import java.util.*;

public class MapIntro {
    public static void main(String[] args) {

        Map<String, Integer> scores = new HashMap<>();

        // Put key-value pairs
        scores.put("Arjun",  88);
        scores.put("Priya",  95);
        scores.put("Rohan",  72);
        scores.put("Sneha",  89);
        scores.put("Arjun",  91);   // duplicate key — overwrites 88

        System.out.println("Map      : " + scores);
        System.out.println("Size     : " + scores.size());
        System.out.println("Arjun    : " + scores.get("Arjun"));
        System.out.println("Has Priya? " + scores.containsKey("Priya"));
        System.out.println("Has 72?    " + scores.containsValue(72));
        System.out.println("Keys     : " + scores.keySet());
        System.out.println("Values   : " + scores.values());
    }
}

import java.util.*;

public class MapCRUD {
    public static void main(String[] args) {

        Map<String, Integer> population = new HashMap<>();

        // ---- CREATE ----
        population.put("Mumbai",    20_667_656);
        population.put("Delhi",     32_941_308);
        population.put("Bengaluru",  8_443_675);
        population.put("Chennai",    7_088_000);
        population.put("Hyderabad",  6_809_970);
        population.putIfAbsent("Delhi", 999);   // ignored — key exists
        population.putIfAbsent("Kolkata", 4_631_392);  // added
        System.out.println("After CREATE: " + population.size() + " cities");

        // ---- READ ----
        System.out.println("Delhi pop  : " + population.get("Delhi"));
        System.out.println("Pune pop   : " + population.get("Pune"));  // null
        System.out.println("Pune (def) : " + population.getOrDefault("Pune", 0));
        System.out.println("Has Mumbai?: " + population.containsKey("Mumbai"));
        System.out.println("All keys   : " + population.keySet());

        // ---- UPDATE ----
        population.put("Chennai", 7_200_000);         // overwrite
        population.replace("Hyderabad", 7_100_000);   // replace only if exists
        System.out.println("Updated Chennai: " + population.get("Chennai"));

        // ---- DELETE ----
        population.remove("Bengaluru");
        population.remove("Kolkata", 999);            // not removed — value mismatch
        System.out.println("After DELETE: " + population.size() + " cities");
        System.out.println("Kolkata still exists: " + population.containsKey("Kolkata"));
        System.out.println("Final map: " + population);
    }
}

import java.util.*;

public class MapIteration {
    public static void main(String[] args) {

        Map<String, Integer> marks = new LinkedHashMap<>();
        marks.put("Maths",   92);
        marks.put("Science", 88);
        marks.put("English", 79);
        marks.put("History", 84);

        // 1. keySet() — iterate over keys only
        System.out.println("1. keySet():");
        for (String subject : marks.keySet()) {
            System.out.println("   " + subject + " -> " + marks.get(subject));
        }

        // 2. values() — iterate over values only
        System.out.println("2. values():");
        int total = 0;
        for (int score : marks.values()) {
            total += score;
        }
        System.out.println("   Total marks: " + total);

        // 3. entrySet() — most efficient: both key and value together
        System.out.println("3. entrySet() (recommended):");
        for (Map.Entry<String, Integer> entry : marks.entrySet()) {
            System.out.println("   " + entry.getKey() + " = " + entry.getValue());
        }

        // 4. Iterator on entrySet — for safe removal during traversal
        System.out.println("4. Iterator (removes History):");
        Iterator<Map.Entry<String, Integer>> it = marks.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry<String, Integer> e = it.next();
            if (e.getKey().equals("History")) it.remove();
            else System.out.println("   " + e.getKey() + " = " + e.getValue());
        }

        // 5. forEach lambda (Java 8+) — cleanest syntax
        System.out.println("5. forEach lambda:");
        marks.forEach((subject, score) ->
            System.out.println("   " + subject + ": " + score + "%"));
    }
}

import java.util.*;
import java.util.stream.*;

public class MapSorting {
    public static void main(String[] args) {

        Map<String, Integer> wordCount = new HashMap<>();
        wordCount.put("java",   45);
        wordCount.put("python", 30);
        wordCount.put("kotlin", 20);
        wordCount.put("scala",  15);
        wordCount.put("groovy",  8);

        // --- Sort by KEY ascending (TreeMap) ---
        Map<String, Integer> sortedByKey = new TreeMap<>(wordCount);
        System.out.println("Sorted by Key (asc): " + sortedByKey);

        // --- Sort by KEY descending ---
        Map<String, Integer> keyDesc = new TreeMap<>(Comparator.reverseOrder());
        keyDesc.putAll(wordCount);
        System.out.println("Sorted by Key (desc): " + keyDesc);

        // --- Sort by VALUE ascending (Stream) ---
        System.out.println("Sorted by Value (asc):");
        wordCount.entrySet().stream()
            .sorted(Map.Entry.comparingByValue())
            .forEach(e -> System.out.println("  " + e.getKey() + " = " + e.getValue()));

        // --- Sort by VALUE descending (Stream) ---
        System.out.println("Sorted by Value (desc):");
        wordCount.entrySet().stream()
            .sorted(Map.Entry.<String, Integer>comparingByValue().reversed())
            .forEach(e -> System.out.println("  " + e.getKey() + " = " + e.getValue()));

        // --- Collect sorted result into LinkedHashMap (preserves order) ---
        Map<String, Integer> sortedMap = wordCount.entrySet().stream()
            .sorted(Map.Entry.<String, Integer>comparingByValue().reversed())
            .collect(Collectors.toMap(
                Map.Entry::getKey,
                Map.Entry::getValue,
                (e1, e2) -> e1,
                LinkedHashMap::new
            ));
        System.out.println("Collected sorted map: " + sortedMap);
    }
}

import java.util.*;

public class Java8MapMethods {
    public static void main(String[] args) {

        // --- getOrDefault ---
        Map<String, Integer> config = new HashMap<>();
        config.put("timeout", 30);
        System.out.println(config.getOrDefault("timeout",  60));  // 30
        System.out.println(config.getOrDefault("retries",   3));  // 3 (default)

        // --- putIfAbsent ---
        config.putIfAbsent("timeout", 999);  // ignored — already set
        config.putIfAbsent("retries", 3);    // added
        System.out.println("Config: " + config);

        // --- computeIfAbsent — frequency counter pattern ---
        Map<String, Integer> freq = new HashMap<>();
        String[] words = {"java", "python", "java", "kotlin", "java", "python"};
        for (String w : words) {
            freq.merge(w, 1, Integer::sum);  // cleanest frequency counter
        }
        System.out.println("Word freq: " + freq);

        // --- computeIfAbsent — grouping pattern ---
        Map<Integer, List<String>> byLength = new HashMap<>();
        String[] names = {"Amit", "Priya", "Rohan", "Dev", "Sneha", "Jo"};
        for (String name : names) {
            byLength.computeIfAbsent(name.length(), k -> new ArrayList<>()).add(name);
        }
        System.out.println("By length: " + byLength);

        // --- replaceAll ---
        Map<String, Integer> prices = new HashMap<>();
        prices.put("Apple",  100);
        prices.put("Banana",  40);
        prices.put("Mango",  120);
        prices.replaceAll((item, price) -> (int)(price * 1.10));  // 10% price hike
        System.out.println("After 10% hike: " + prices);

        // --- merge — combine two maps ---
        Map<String, Integer> shopA = new HashMap<>(Map.of("Apple", 50, "Banana", 30));
        Map<String, Integer> shopB = new HashMap<>(Map.of("Apple", 20, "Mango",  40));
        shopB.forEach((k, v) -> shopA.merge(k, v, Integer::sum));
        System.out.println("Combined stock: " + shopA);
    }
}

import java.util.*;

public class NestedMapDemo {
    public static void main(String[] args) {

        // Map<StudentName, Map<Subject, Score>>
        Map<String, Map<String, Integer>> reportCard = new HashMap<>();

        // Add Arjun's scores
        Map<String, Integer> arjunScores = new LinkedHashMap<>();
        arjunScores.put("Maths",   92);
        arjunScores.put("Science", 88);
        arjunScores.put("English", 76);
        reportCard.put("Arjun", arjunScores);

        // Add Priya's scores using computeIfAbsent
        reportCard.computeIfAbsent("Priya", k -> new LinkedHashMap<>()).put("Maths",   95);
        reportCard.computeIfAbsent("Priya", k -> new LinkedHashMap<>()).put("Science", 91);
        reportCard.computeIfAbsent("Priya", k -> new LinkedHashMap<>()).put("English", 83);

        // Print full report card
        System.out.println("=== Report Card ===");
        reportCard.forEach((student, subjects) -> {
            System.out.println("\n" + student + ":");
            subjects.forEach((subject, score) ->
                System.out.printf("  %-10s: %d%n", subject, score));
            int avg = subjects.values().stream()
                          .mapToInt(Integer::intValue).sum() / subjects.size();
            System.out.println("  Average   : " + avg);
        });

        // Access specific cell
        int priyaMaths = reportCard.get("Priya").getOrDefault("Maths", 0);
        System.out.println("\nPriya's Maths score: " + priyaMaths);
    }
}

import java.util.*;

public class MapBestPractices {
    public static void main(String[] args) {

        String[] fruits = {"apple","banana","apple","mango","banana","apple"};

        // ❌ Verbose anti-pattern
        Map<String, Integer> badCount = new HashMap<>();
        for (String f : fruits) {
            if (badCount.containsKey(f)) {
                badCount.put(f, badCount.get(f) + 1);
            } else {
                badCount.put(f, 1);
            }
        }
        System.out.println("Verbose : " + badCount);

        // ✅ getOrDefault pattern (Java 8+)
        Map<String, Integer> count1 = new HashMap<>();
        for (String f : fruits)
            count1.put(f, count1.getOrDefault(f, 0) + 1);
        System.out.println("getOrDefault: " + count1);

        // ✅ merge — cleanest (Java 8+)
        Map<String, Integer> count2 = new HashMap<>();
        for (String f : fruits)
            count2.merge(f, 1, Integer::sum);
        System.out.println("merge       : " + count2);

        // ✅ entrySet iteration vs keySet iteration
        System.out.println("\nentrySet (efficient):");
        for (Map.Entry<String, Integer> e : count2.entrySet())
            System.out.println("  " + e.getKey() + " -> " + e.getValue());
    }
}

import java.util.*;
import java.util.stream.*;

class Employee {
    int    id;
    String name;
    String dept;
    double salary;

    Employee(int id, String name, String dept, double salary) {
        this.id = id; this.name = name;
        this.dept = dept; this.salary = salary;
    }

    @Override public String toString() {
        return name + "(" + dept + ", ₹" + salary + ")";
    }
}

public class EmployeeDirectory {
    public static void main(String[] args) {

        Map<Integer, Employee> directory = new HashMap<>();
        directory.put(101, new Employee(101, "Arjun",  "Engineering", 85000));
        directory.put(102, new Employee(102, "Priya",  "Marketing",   72000));
        directory.put(103, new Employee(103, "Rohan",  "Engineering", 91000));
        directory.put(104, new Employee(104, "Sneha",  "HR",          68000));
        directory.put(105, new Employee(105, "Vikram", "Engineering", 78000));

        // Lookup by ID — O(1)
        System.out.println("Employee 103: " + directory.get(103));

        // Group by department
        Map<String, List<Employee>> byDept = new HashMap<>();
        directory.values().forEach(e ->
            byDept.computeIfAbsent(e.dept, k -> new ArrayList<>()).add(e));

        System.out.println("\nBy Department:");
        byDept.forEach((dept, emps) -> System.out.println("  " + dept + ": " + emps));

        // Average salary by department
        System.out.println("\nAvg Salary:");
        byDept.forEach((dept, emps) -> {
            double avg = emps.stream().mapToDouble(e -> e.salary).average().orElse(0);
            System.out.printf("  %-15s: ₹%.0f%n", dept, avg);
        });

        // Highest paid employee
        Employee top = directory.values().stream()
            .max(Comparator.comparingDouble(e -> e.salary)).orElseThrow();
        System.out.println("\nHighest paid: " + top);
    }
}

import java.util.*;

public class Leaderboard {
    public static void main(String[] args) {

        // TreeMap sorted by score descending (reverse order)
        TreeMap<Integer, String> board =
            new TreeMap<>(Comparator.reverseOrder());

        board.put(88,  "Arjun");
        board.put(95,  "Priya");
        board.put(72,  "Rohan");
        board.put(89,  "Sneha");
        board.put(100, "Vikram");
        board.put(65,  "Aisha");

        System.out.println("=== Leaderboard ===");
        int rank = 1;
        for (Map.Entry<Integer, String> e : board.entrySet()) {
            System.out.printf("#%d  %-10s %d pts%n", rank++, e.getValue(), e.getKey());
        }

        // NavigableMap operations
        System.out.println("\nTop scorer : " + board.firstEntry());
        System.out.println("Scores > 85: " + board.headMap(85, false));
        System.out.println("Floor of 90: " + board.floorKey(90));
        System.out.println("Ceiling of 90: " + board.ceilingKey(90));
    }
}