Map<String, Material> index = new HashMap<>();
index.put("978-0000000001", effectiveJava);
index.put("978-0000000002", designPatterns);

Material found = index.get("978-0000000001");     // instant

// Before: O(n). With 50,000 materials, up to 50,000 string comparisons.
public Material findByReference(String reference) {
    for (Material m : materials) {
        if (m.getReference().equals(reference)) { return m; }
    }
    return null;
}

// Now: O(1). One operation, always, whether the map has 10 or 10,000,000 entries.
public Material findByReference(String reference) {
    return index.get(reference);
}

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

Map<String, Material> index = new HashMap<>();

Material previous = index.put("978-0000000001", effectiveJava);
System.out.println(previous);      // null: there was nothing with that key

Material former = index.put("978-0000000001", otherEdition);
System.out.println(former);        // the earlier effectiveJava: it has been REPLACED

Material m = index.get("978-0000000001");      // the value, or null if absent
Material x = index.get("does-not-exist");      // null

// getOrDefault avoids the null and a whole family of checks
int term = termsByType.getOrDefault("Audiobook", 15);       // 15 if it is not registered

Integer value = map.get(key);
int result = (value == null) ? 0 : value;

int result = map.getOrDefault(key, 0);

boolean isCatalogued = index.containsKey("978-0000000001");      // O(1)
boolean bookAppears  = index.containsValue(effectiveJava);       // O(n): walks EVERYTHING

Material removed = index.remove("978-0000000001");    // returns the removed value, or null
boolean wasRemoved = index.remove("978-0000000002", designPatterns);   // only if the value matches

System.out.println(index.size());         // number of pairs
System.out.println(index.isEmpty());
index.clear();

Map<String, Material> index = new HashMap<>();
// ... filled ...

// 1. Keys only
for (String reference : index.keySet()) {
    System.out.println(reference);
}

// 2. Values only
for (Material m : index.values()) {
    System.out.println(m.getTitle());
}

// 3. Keys AND values: ALWAYS with entrySet
for (Map.Entry<String, Material> entry : index.entrySet()) {
    System.out.printf("%-16s -> %s%n", entry.getKey(), entry.getValue().getTitle());
}

// INEFFICIENT: two operations per entry
for (String reference : index.keySet()) {
    Material m = index.get(reference);          // an extra, unnecessary lookup
    System.out.println(reference + " -> " + m.getTitle());
}

for (Map.Entry<String, Integer> e : counters.entrySet()) {
    e.setValue(e.getValue() + 1);      // legal and efficient
}

index.forEach((reference, material) ->
    System.out.printf("%-16s -> %s%n", reference, material.getTitle()));

index.keySet().remove("978-0000000001");      // removes the WHOLE entry
index.values().removeIf(m -> !m.isAvailable());     // removes the entries whose values match

// Instead of:
if (!index.containsKey(ref)) { index.put(ref, material); }

// Write:
index.putIfAbsent(ref, material);

// WITHOUT computeIfAbsent: the classic pattern, verbose and easy to break
Map<Employee, List<Loan>> byEmployee = new HashMap<>();
for (Loan l : loans) {
    List<Loan> list = byEmployee.get(l.getEmployee());
    if (list == null) {
        list = new ArrayList<>();
        byEmployee.put(l.getEmployee(), list);
    }
    list.add(l);
}

// WITH computeIfAbsent: one line
for (Loan l : loans) {
    byEmployee.computeIfAbsent(l.getEmployee(), k -> new ArrayList<>()).add(l);
}

Map<String, List<Material>> byType = new HashMap<>();
for (Material m : catalog) {
    byType.computeIfAbsent(m.getType(), type -> new ArrayList<>()).add(m);
}

// WITHOUT merge
Map<String, Integer> countByType = new HashMap<>();
for (Material m : catalog) {
    Integer current = countByType.get(m.getType());
    countByType.put(m.getType(), (current == null) ? 1 : current + 1);
}

// WITH merge
for (Material m : catalog) {
    countByType.merge(m.getType(), 1, Integer::sum);
}

Map<Employee, Double> fineByEmployee = new HashMap<>();
for (Loan l : loans) {
    fineByEmployee.merge(l.getEmployee(), l.calculateFine(currentDay), Double::sum);
}

Map<String, String> titlesByType = new HashMap<>();
for (Material m : catalog) {
    titlesByType.merge(m.getType(), m.getTitle(), (a, b) -> a + ", " + b);
}

countByType.put(type, countByType.getOrDefault(type, 0) + 1);

// compute: ALWAYS recomputes, with the current value (which may be null)
counters.compute("Book", (k, v) -> (v == null) ? 1 : v + 1);

// computeIfPresent: only acts if the key ALREADY exists
inventory.computeIfPresent("978-0000000001", (k, v) -> v - 1);

// Deducts one unit and removes the entry when it reaches zero
inventory.computeIfPresent(isbn, (k, v) -> (v <= 1) ? null : v - 1);

rates.replaceAll((type, rate) -> rate * 1.10);         // a 10% rise across the board

transient Node<K,V>[] table;          // the array of buckets
transient int size;                   // number of pairs stored
int threshold;                        // capacity * load factor
final float loadFactor;               // 0.75 by default

"978-0000000001".hashCode();     // for example, -1234567890

int index = (table.length - 1) & hash;     // equals hash % 16 when length is a power of 2

static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

Material m = index.get("978-0000000001");
// 1. hash of the key -> 2. bucket index -> 3. look in that bucket

@Override public int hashCode() { return 42; }    // legal, but catastrophic

threshold = capacity × loadFactor

// Bad: 50,000 entries cause about 12 rehashes, with O(n) rehoming every time
Map<String, Material> index = new HashMap<>();

// Good: enough capacity from the start
Map<String, Material> index = new HashMap<>((int) (50_000 / 0.75f) + 1);

package com.nexussoftware.bibliotech.domain;

import java.util.Objects;

/** Composite key of a copy. equals correct, hashCode MISSING. */
public class BrokenCopyKey {

    private final String isbn;
    private final int    copyNumber;

    public BrokenCopyKey(String isbn, int copyNumber) {
        this.isbn = isbn;
        this.copyNumber = copyNumber;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) { return true; }
        if (!(o instanceof BrokenCopyKey other)) { return false; }
        return copyNumber == other.copyNumber && Objects.equals(isbn, other.isbn);
    }

    // hashCode IS MISSING: Object's is inherited, based on the memory address
}

BrokenCopyKey c1 = new BrokenCopyKey("978-0000000001", 1);
BrokenCopyKey c2 = new BrokenCopyKey("978-0000000001", 1);

System.out.println("c1.equals(c2): " + c1.equals(c2));            // true: they are "equal"
System.out.println("hash c1: " + c1.hashCode());                  // 1735600054  (for example)
System.out.println("hash c2: " + c2.hashCode());                  // 21685669    DIFFERENT

Map<BrokenCopyKey, String> locations = new HashMap<>();
locations.put(c1, "Shelf A-3");

System.out.println("get(c1): " + locations.get(c1));              // Shelf A-3
System.out.println("get(c2): " + locations.get(c2));              // null   <-- THE PROBLEM
System.out.println("containsKey(c2): " + locations.containsKey(c2));   // false
System.out.println("size: " + locations.size());                  // 1

locations.put(c2, "Shelf B-1");
System.out.println("size after putting c2: " + locations.size()); // 2  <-- DUPLICATE KEY

package com.nexussoftware.bibliotech.domain;

import java.util.Objects;

/** The same key, with CONSISTENT equals and hashCode. */
public class CopyKey {

    private final String isbn;
    private final int    copyNumber;

    public CopyKey(String isbn, int copyNumber) {
        this.isbn = Objects.requireNonNullElse(isbn, "");
        this.copyNumber = copyNumber;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) { return true; }
        if (!(o instanceof CopyKey other)) { return false; }
        return copyNumber == other.copyNumber && isbn.equals(other.isbn);
    }

    /** The SAME fields that equals uses, not one more, not one less. */
    @Override
    public int hashCode() {
        return Objects.hash(isbn, copyNumber);
    }

    @Override
    public String toString() {
        return isbn + "#" + copyNumber;
    }
}

CopyKey c1 = new CopyKey("978-0000000001", 1);
CopyKey c2 = new CopyKey("978-0000000001", 1);

System.out.println("hash c1: " + c1.hashCode());     // 1635958654
System.out.println("hash c2: " + c2.hashCode());     // 1635958654   THE SAME

Map<CopyKey, String> locations = new HashMap<>();
locations.put(c1, "Shelf A-3");

System.out.println("get(c2): " + locations.get(c2));     // Shelf A-3   <-- IT WORKS
locations.put(c2, "Shelf B-1");
System.out.println("size: " + locations.size());         // 1: c2 REPLACED c1

public record CopyKeyRecord(String isbn, int copyNumber) { }   // already a valid key

package com.nexussoftware.bibliotech.domain;

import java.util.Objects;

/** MUTABLE key: the isbn field can change. A bad idea. */
public class MutableKey {
    private String isbn;                       // NOT final

    public MutableKey(String isbn) { this.isbn = isbn; }
    public void setIsbn(String isbn) { this.isbn = isbn; }    // the poison

    @Override public boolean equals(Object o) {
        return (o instanceof MutableKey k) && Objects.equals(isbn, k.isbn);
    }
    @Override public int hashCode() { return Objects.hash(isbn); }
    @Override public String toString() { return "Key[" + isbn + "]"; }
}

MutableKey key = new MutableKey("978-0000000001");
Map<MutableKey, String> map = new HashMap<>();
map.put(key, "Effective Java");

System.out.println(map.get(key));          // Effective Java   correct

key.setIsbn("978-0000000002");             // we MUTATE the key ALREADY INSERTED

System.out.println(map.get(key));          // null   <-- the object has been lost
System.out.println(map.size());            // 1      <-- but it is still in there
System.out.println(map.containsKey(key));  // false
System.out.println(map);                   // {Key[978-0000000002]=Effective Java}

List<String> list = new ArrayList<>(List.of("a", "b"));
Map<List<String>, String> map = new HashMap<>();
map.put(list, "value");

list.add("c");                          // a list's hashCode DEPENDS on its content (05-03)
System.out.println(map.get(list));      // null

// If Employee had equals/hashCode based on the name and the name could change:
Map<Employee, List<Loan>> byEmployee = new HashMap<>();
byEmployee.put(marta, martasLoans);
marta.setName("Marta Ruiz Garcia");     // a silent catastrophe

/** Identifies a specific copy: same ISBN, different copy number. */
public record CopyKey(String isbn, int copyNumber) {
    public CopyKey {
        if (isbn == null || isbn.isBlank()) { isbn = "NO-ISBN"; }
        if (copyNumber < 1) { copyNumber = 1; }
    }
}

Map<CopyKey, String> locations = new HashMap<>();
locations.put(new CopyKey("978-0000000001", 1), "Shelf A-3");
locations.put(new CopyKey("978-0000000001", 2), "Shelf A-4");

System.out.println(locations.get(new CopyKey("978-0000000001", 2)));     // Shelf A-4

Map<String, Integer> terms = new LinkedHashMap<>();
terms.put("Book", 15);
terms.put("Magazine", 7);
terms.put("DVD", 3);

terms.forEach((type, days) -> System.out.println(type + ": " + days));
// ALWAYS in this order: Book, Magazine, DVD

TreeMap<String, Material> byReference = new TreeMap<>();
byReference.put("978-0000000002", designPatterns);
byReference.put("978-0000000001", effectiveJava);
byReference.put("978-0000000003", refactoring);

// Always sorted, with no manual sorting
byReference.forEach((k, v) -> System.out.println(k + " -> " + v.getTitle()));

System.out.println(byReference.firstKey());          // 978-0000000001
System.out.println(byReference.lastKey());           // 978-0000000003
System.out.println(byReference.firstEntry());        // the complete pair

// Navigation: NavigableMap
System.out.println(byReference.floorKey("978-0000000002x"));     // greatest key <= the given one
System.out.println(byReference.ceilingKey("978-0000000000"));    // smallest key >= the given one
System.out.println(byReference.higherKey("978-0000000001"));     // strictly greater
System.out.println(byReference.lowerKey("978-0000000003"));      // strictly smaller

// Range views, which are LIVE VIEWS of the original map
SortedMap<String, Material> firstOnes = byReference.headMap("978-0000000003");  // < the given one
SortedMap<String, Material> lastOnes  = byReference.tailMap("978-0000000002");  // >= the given one
NavigableMap<String, Material> stretch = byReference.subMap("978-0000000001", true,
                                                            "978-0000000002", true);

System.out.println(byReference.descendingMap().firstKey());      // reverse traversal

// Sorted by key length and, on a tie, alphabetically
Map<String, Integer> custom = new TreeMap<>(
    Comparator.comparingInt(String::length).thenComparing(Comparator.naturalOrder()));

new LinkedHashMap<>(initialCapacity, loadFactor, accessOrder);

package com.nexussoftware.bibliotech.service;

import java.util.LinkedHashMap;
import java.util.Map;

/** LRU cache: keeps the N most recently consulted cards. */
public class CardCache<K, V> extends LinkedHashMap<K, V> {

    private final int max;

    public CardCache(int max) {
        super(16, 0.75f, true);      // accessOrder = true: reorders on every get
        this.max = max;
    }

    @Override
    protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
        return size() > max;         // if it returns true, LinkedHashMap evicts it
    }
}

CardCache<String, String> cache = new CardCache<>(3);

cache.put("978-0000000001", "Effective Java");
cache.put("978-0000000002", "Design Patterns");
cache.put("978-0000000003", "Refactoring");
System.out.println(cache.keySet());      // [...001, ...002, ...003]

cache.get("978-0000000001");             // we consult the FIRST one: it moves to the end
System.out.println(cache.keySet());      // [...002, ...003, ...001]

cache.put("978-0000000004", "Clean Code");      // exceeds the maximum
System.out.println(cache.keySet());      // [...003, ...001, ...004]
// ...002 has gone: it was the least recently used

package com.nexussoftware.bibliotech.service;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Predicate;
import com.nexussoftware.bibliotech.domain.Material;

/** Catalogue with an index by reference: O(1) lookups. */
public class Catalog {

    private final List<Material>          materials   = new ArrayList<>();
    private final Map<String, Material>   byReference = new HashMap<>();
    private final Map<String, List<Material>> byType  = new HashMap<>();

    /** Registration: keeps the three containers in sync. */
    public boolean add(Material m) {
        if (m == null) { return false; }
        // putIfAbsent returns the existing value, or null if it inserted
        if (byReference.putIfAbsent(m.getReference(), m) != null) {
            return false;                       // duplicate reference: registration rejected
        }
        materials.add(m);
        byType.computeIfAbsent(m.getType(), type -> new ArrayList<>()).add(m);
        return true;
    }

    /** Lookup by reference: O(1). It used to be O(n). */
    public Material findByReference(String reference) {
        return byReference.get(reference);
    }

    public boolean isCatalogued(String reference) {
        return byReference.containsKey(reference);
    }

    /** Removal: O(1) to locate it, O(n) to take it out of the list. */
    public boolean remove(String reference) {
        Material m = byReference.remove(reference);
        if (m == null) { return false; }
        materials.remove(m);
        // If the group is left empty, the entry is removed from the map (function returning null)
        byType.computeIfPresent(m.getType(),
                (type, list) -> { list.remove(m); return list.isEmpty() ? null : list; });
        return true;
    }

    /** All the materials of a type: O(1). It used to be a complete walk. */
    public List<Material> ofType(String type) {
        return List.copyOf(byType.getOrDefault(type, List.of()));
    }

    /** Report by type: it used to be 20 lines with nested O(n^2) loops. */
    public Map<String, Integer> countByType() {
        Map<String, Integer> summary = new HashMap<>();
        for (Material m : materials) {
            summary.merge(m.getType(), 1, Integer::sum);
        }
        return summary;
    }

    /** Sum of daily rates grouped by type, also with merge. */
    public Map<String, Double> totalRateByType() {
        Map<String, Double> summary = new HashMap<>();
        for (Material m : materials) {
            summary.merge(m.getType(), m.getDailyRate(), Double::sum);
        }
        return summary;
    }

    public List<Material> find(Predicate<Material> criteria) {
        List<Material> result = new ArrayList<>();
        for (Material m : materials) {
            if (criteria.test(m)) { result.add(m); }
        }
        return result;
    }

    public void sort(Comparator<Material> criteria) { materials.sort(criteria); }
    public List<Material> list() { return List.copyOf(materials); }
    public int size() { return materials.size(); }
}

// BEFORE: nested loops, O(n * types), 20 lines
public void reportByType(Material[] catalog) {
    String[] types = { "Book", "Magazine", "DVD", "Audiobook" };
    for (int t = 0; t < types.length; t++) {
        int howMany = 0;
        double rate = 0.0;
        for (int i = 0; i < catalog.length; i++) {
            if (catalog[i] != null && catalog[i].getType().equals(types[t])) {
                howMany++;
                rate += catalog[i].getDailyRate();
            }
        }
        if (howMany > 0) {
            System.out.printf("%-12s %3d materials, average rate %.2f%n",
                              types[t], howMany, rate / howMany);
        }
    }
}

// NOW: one pass, O(n), and with no hand-coded list of types
public void reportByType() {
    Map<String, Integer> howMany = countByType();
    Map<String, Double>  rates   = totalRateByType();
    howMany.forEach((type, n) ->
        System.out.printf("%-12s %3d materials, average rate %.2f%n",
                          type, n, rates.get(type) / n));
}

package com.nexussoftware.bibliotech.service;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import com.nexussoftware.bibliotech.domain.Employee;
import com.nexussoftware.bibliotech.domain.Loan;

public class LoanRegistry {

    private final Map<String, Loan>            byReference = new HashMap<>();
    private final Map<Employee, List<Loan>>    byEmployee  = new HashMap<>();

    /**
     * Employee as a KEY: it requires correct equals/hashCode based on an
     * IMMUTABLE field. In BiblioTech they are based on 'identifier', which is final.
     */
    public void register(Loan l) {
        if (l == null) { return; }
        byReference.put(l.getReference(), l);
        byEmployee.computeIfAbsent(l.getEmployee(), e -> new ArrayList<>()).add(l);
    }

    /** Return in O(1): it used to walk the whole list of loans. */
    public boolean returnItem(String loanReference, int day) {
        Loan l = byReference.get(loanReference);
        if (l == null || l.isReturned()) { return false; }
        l.registerReturn(day);
        return true;
    }

    /** An employee's loans in O(1): it used to be a complete walk. */
    public List<Loan> of(Employee employee) {
        return List.copyOf(byEmployee.getOrDefault(employee, List.of()));
    }

    /** Accumulated fine per employee, with merge. */
    public Map<Employee, Double> finesByEmployee(int currentDay) {
        Map<Employee, Double> fines = new HashMap<>();
        for (List<Loan> list : byEmployee.values()) {
            for (Loan l : list) {
                if (!l.isReturned() && l.isOverdue(currentDay)) {
                    fines.merge(l.getEmployee(), l.calculateFine(currentDay), Double::sum);
                }
            }
        }
        return fines;
    }

    /** How many active loans each employee has. */
    public Map<Employee, Integer> activeByEmployee() {
        Map<Employee, Integer> active = new HashMap<>();
        for (Map.Entry<Employee, List<Loan>> e : byEmployee.entrySet()) {
            int n = 0;
            for (Loan l : e.getValue()) {
                if (!l.isReturned()) { n++; }
            }
            if (n > 0) { active.put(e.getKey(), n); }
        }
        return active;
    }
}

Employee marta = new Employee("Marta Ruiz",   "EMP-001");
Employee diego = new Employee("Diego Alonso", "EMP-002");

Catalog catalog = new Catalog();
catalog.add(new Book("Effective Java",  "Joshua Bloch",  "978-0000000001", 2018));
catalog.add(new Book("Design Patterns", "Erich Gamma",   "978-0000000002", 1994));
catalog.add(new Book("Refactoring",     "Martin Fowler", "978-0000000003", 1999));
catalog.add(new Magazine("Java Magazine", "REV-2024-03", 42, "Monthly"));
catalog.add(new Dvd("Refactoring Live", "DVD-0007",      95));

// Instant lookup, walking nothing
Material m = catalog.findByReference("978-0000000002");
System.out.println("Found: " + m.getTitle());

System.out.println("--- Report by type ---");
catalog.countByType().forEach((type, n) -> System.out.printf("  %-8s %d%n", type, n));

LoanRegistry registry = new LoanRegistry();
registry.register(new Loan(catalog.findByReference("978-0000000001"), marta, 100));
registry.register(new Loan(catalog.findByReference("978-0000000003"), marta, 102));
registry.register(new Loan(catalog.findByReference("DVD-0007"),       diego, 105));

System.out.println("Loans for Marta: " + registry.of(marta).size());
System.out.println("--- Fines on day 130 ---");
registry.finesByEmployee(130).forEach((e, fine) ->
    System.out.printf("  %-14s %6.2f EUR%n", e.getName(), fine));

Found: Design Patterns
--- Report by type ---
  Book     3
  Magazine 1
  DVD      1
Loans for Marta: 2
--- Fines on day 130 ---
  Marta Ruiz      20.00 EUR
  Diego Alonso    12.50 EUR

package com.nexussoftware.bibliotech.service;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import com.nexussoftware.bibliotech.domain.Material;

/** Inverted index: from each word to the materials containing it in the title. */
public class SearchIndex {

    private final Map<String, List<Material>> byWord    = new HashMap<>();
    private final Map<String, Integer>        frequency = new HashMap<>();

    private static List<String> wordsOf(Material m) {
        if (m == null || m.getTitle() == null) { return List.of(); }
        List<String> words = new ArrayList<>();
        for (String w : m.getTitle().toLowerCase().split("\\s+")) {
            if (w.length() > 2) { words.add(w); }      // we discard "of", "the", "in"...
        }
        return words;
    }

    public void index(Material m) {
        for (String word : wordsOf(m)) {
            // computeIfAbsent: creates the list ONLY if the word is new,
            // and always returns a valid list to chain add onto
            byWord.computeIfAbsent(word, w -> new ArrayList<>()).add(m);
            // merge: if the word is new it stores 1; if it exists, it adds
            frequency.merge(word, 1, Integer::sum);
        }
    }

    /** getOrDefault avoids returning null and the caller's checks. */
    public List<Material> find(String word) {
        if (word == null) { return List.of(); }
        return List.copyOf(byWord.getOrDefault(word.toLowerCase(), List.of()));
    }

    public Map<String, Integer> frequencies() {
        return Map.copyOf(frequency);         // immutable copy
    }

    public List<String> mostCommonWords(int howMany) {
        // We dump the keys into a list and sort it by descending frequency.
        // A TreeMap would not help: it sorts by KEY, not by value.
        List<String> words = new ArrayList<>(frequency.keySet());
        words.sort(Comparator.comparingInt((String w) -> frequency.get(w)).reversed()
                             .thenComparing(Comparator.naturalOrder()));
        return words.subList(0, Math.min(howMany, words.size()));
    }

    public void remove(Material m) {
        for (String word : wordsOf(m)) {
            // If the function returns null, computeIfPresent REMOVES the entry from the map.
            byWord.computeIfPresent(word, (w, list) -> {
                list.remove(m);
                return list.isEmpty() ? null : list;
            });
            frequency.computeIfPresent(word, (w, n) -> (n <= 1) ? null : n - 1);
        }
    }

    public int indexedWords() { return byWord.size(); }
}

SearchIndex index = new SearchIndex();
index.index(new Book("Effective Java",     "Joshua Bloch",  "978-0000000001", 2018));
index.index(new Book("Design Patterns",    "Erich Gamma",   "978-0000000002", 1994));
index.index(new Book("Refactoring",        "Martin Fowler", "978-0000000003", 1999));
index.index(new Magazine("Java Magazine",  "REV-2024-03",   42, "Monthly"));
index.index(new Dvd("Refactoring Live",    "DVD-0007",      95));

System.out.println("With 'java': " + index.find("java").size());                 // 2
System.out.println("With 'refactoring': " + index.find("refactoring").size());   // 2
System.out.println("Most common: " + index.mostCommonWords(3));

package com.nexussoftware.bibliotech.presentation;

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

public class HashCodeDemo {

    // --- 1. equals WITHOUT hashCode ---
    static class BrokenKey {
        final String isbn;
        BrokenKey(String isbn) { this.isbn = isbn; }
        @Override public boolean equals(Object o) {
            return (o instanceof BrokenKey k) && Objects.equals(isbn, k.isbn);
        }
        // no hashCode: Object's is inherited (based on identity)
        @Override public String toString() { return "Broken[" + isbn + "]"; }
    }

    // --- 2. consistent equals AND hashCode ---
    static class CorrectKey {
        final String isbn;
        CorrectKey(String isbn) { this.isbn = isbn; }
        @Override public boolean equals(Object o) {
            return (o instanceof CorrectKey k) && Objects.equals(isbn, k.isbn);
        }
        @Override public int hashCode() { return Objects.hash(isbn); }
        @Override public String toString() { return "Correct[" + isbn + "]"; }
    }

    // --- 3. a MUTABLE key ---
    static class MutableKey {
        String isbn;                        // not final: the problem
        MutableKey(String isbn) { this.isbn = isbn; }
        @Override public boolean equals(Object o) {
            return (o instanceof MutableKey k) && Objects.equals(isbn, k.isbn);
        }
        @Override public int hashCode() { return Objects.hash(isbn); }
        @Override public String toString() { return "Mutable[" + isbn + "]"; }
    }

    // --- 4. record: equals and hashCode FOR FREE ---
    record RecordKey(String isbn, int copy) { }

    // --- 5. constant hashCode: legal but catastrophic ---
    static class SillyKey {
        final String isbn;
        SillyKey(String isbn) { this.isbn = isbn; }
        @Override public boolean equals(Object o) {
            return (o instanceof SillyKey k) && Objects.equals(isbn, k.isbn);
        }
        @Override public int hashCode() { return 42; }   // ALL in the same bucket
    }

    public static void main(String[] args) {
        demoBroken();
        demoCorrect();
        demoMutable();
        demoRecord();
        demoSilly();
    }

    static void demoBroken() {
        System.out.println("=== 1. equals WITHOUT hashCode ===");
        BrokenKey a = new BrokenKey("978-0000000001");
        BrokenKey b = new BrokenKey("978-0000000001");

        System.out.println("a.equals(b): " + a.equals(b));            // true
        System.out.println("hash a: " + a.hashCode());
        System.out.println("hash b: " + b.hashCode() + "   <- DIFFERENT");

        Map<BrokenKey, String> map = new HashMap<>();
        map.put(a, "Shelf A-3");
        System.out.println("get(a): " + map.get(a));                  // Shelf A-3
        System.out.println("get(b): " + map.get(b) + "   <- it has been LOST");

        map.put(b, "Shelf B-1");
        System.out.println("size after putting b: " + map.size() + "   <- DUPLICATE KEY");
        System.out.println("Cause: get(b) computes b's hash, goes to ANOTHER bucket,");
        System.out.println("       finds it empty and returns null. equals is NEVER called.\n");
    }

    static void demoCorrect() {
        System.out.println("=== 2. equals AND hashCode ===");
        CorrectKey a = new CorrectKey("978-0000000001");
        CorrectKey b = new CorrectKey("978-0000000001");

        System.out.println("hash a == hash b: " + (a.hashCode() == b.hashCode()));  // true

        Map<CorrectKey, String> map = new HashMap<>();
        map.put(a, "Shelf A-3");
        System.out.println("get(b): " + map.get(b) + "   <- IT WORKS");
        map.put(b, "Shelf B-1");
        System.out.println("size: " + map.size() + "   <- b REPLACED a\n");
    }

    static void demoMutable() {
        System.out.println("=== 3. a MUTABLE key ===");
        MutableKey key = new MutableKey("978-0000000001");
        Map<MutableKey, String> map = new HashMap<>();
        map.put(key, "Effective Java");
        System.out.println("get before mutating: " + map.get(key));

        key.isbn = "978-0000000002";          // we mutate the key ALREADY inserted

        System.out.println("get after mutating:  " + map.get(key) + "   <- LOST");
        System.out.println("containsKey:         " + map.containsKey(key));
        System.out.println("size:                " + map.size() + "   <- still in there");
        System.out.println("contents:            " + map);
        System.out.println("The entry is in the bucket of the OLD hash. Nobody rehomes it:");
        System.out.println("it is memory occupied and unrecoverable, not even with remove.\n");
    }

    static void demoRecord() {
        System.out.println("=== 4. record ===");
        Map<RecordKey, String> map = new HashMap<>();
        map.put(new RecordKey("978-0000000001", 1), "Shelf A-3");
        map.put(new RecordKey("978-0000000001", 2), "Shelf A-4");

        System.out.println("get(a new equal instance): "
                           + map.get(new RecordKey("978-0000000001", 2)));
        System.out.println("size: " + map.size());
        System.out.println("Zero methods written: the record generates them consistently.\n");
    }

    static void demoSilly() {
        System.out.println("=== 5. constant hashCode ===");
        final int N = 50_000;

        Map<CorrectKey, Integer> good = new HashMap<>();
        long t1 = System.nanoTime();
        for (int i = 0; i < N; i++) { good.put(new CorrectKey("ref-" + i), i); }
        for (int i = 0; i < N; i++) { good.get(new CorrectKey("ref-" + i)); }
        long msGood = (System.nanoTime() - t1) / 1_000_000;

        Map<SillyKey, Integer> silly = new HashMap<>();
        long t2 = System.nanoTime();
        for (int i = 0; i < N; i++) { silly.put(new SillyKey("ref-" + i), i); }
        for (int i = 0; i < N; i++) { silly.get(new SillyKey("ref-" + i)); }
        long msSilly = (System.nanoTime() - t2) / 1_000_000;

        System.out.printf("hashCode well distributed: %5d ms%n", msGood);
        System.out.printf("hashCode constant (42):    %5d ms%n", msSilly);
        System.out.println("Every key lands in the SAME bucket. Since Java 8 that bucket");
        System.out.println("becomes a tree, so it degrades to O(log n) instead of O(n);");
        System.out.println("without that safety net it would be catastrophic.");
    }
}

=== 1. equals WITHOUT hashCode ===
a.equals(b): true
hash a: 1735600054
hash b: 21685669   <- DIFFERENT
get(a): Shelf A-3
get(b): null   <- it has been LOST
size after putting b: 2   <- DUPLICATE KEY
...
=== 5. constant hashCode ===
hashCode well distributed:    38 ms
hashCode constant (42):     1420 ms

package com.nexussoftware.bibliotech.service;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import com.nexussoftware.bibliotech.domain.Employee;
import com.nexussoftware.bibliotech.domain.Severity;
import com.nexussoftware.bibliotech.domain.Loan;

public class LibraryStatistics {

    private final List<Loan> loans;

    public LibraryStatistics(List<Loan> loans) {
        this.loans = (loans == null) ? List.of() : List.copyOf(loans);
    }

    /** merge: the counter pattern in one line. */
    public Map<Employee, Integer> loansByEmployee() {
        Map<Employee, Integer> result = new HashMap<>();
        for (Loan l : loans) {
            result.merge(l.getEmployee(), 1, Integer::sum);
        }
        return result;
    }

    /** merge with Double::sum: an accumulator, the same pattern. */
    public Map<String, Double> totalFineByType(int currentDay) {
        Map<String, Double> result = new HashMap<>();
        for (Loan l : loans) {
            double fine = l.calculateFine(currentDay);
            if (fine > 0) {
                result.merge(l.getMaterial().getType(), fine, Double::sum);
            }
        }
        return result;
    }

    /** computeIfAbsent: the map-of-lists pattern. */
    public Map<Severity, List<Loan>> groupedBySeverity(int currentDay) {
        Map<Severity, List<Loan>> result = new HashMap<>();
        for (Loan l : loans) {
            Severity s = l.getMaterial().classifySeverity(currentDay);
            result.computeIfAbsent(s, key -> new ArrayList<>()).add(l);
        }
        return result;
        // Note: with an enum as the key, EnumMap would be even more efficient.
        // In 10-04 this will be Collectors.groupingBy in a single expression.
    }

    /** A walk over entrySet to keep the maximum. */
    public Employee busiestEmployee() {
        Employee best = null;
        int max = 0;
        for (Map.Entry<Employee, Integer> e : loansByEmployee().entrySet()) {
            if (e.getValue() > max) {
                max  = e.getValue();
                best = e.getKey();
            }
        }
        return best;       // null if there are no loans
    }

    /**
     * The N most borrowed materials, IN ORDER.
     * A HashMap does not preserve order, so we have to dump, sort and
     * rebuild into a LinkedHashMap, which does preserve it.
     */
    public Map<String, Integer> topMaterials(int howMany) {
        Map<String, Integer> count = new HashMap<>();
        for (Loan l : loans) {
            count.merge(l.getMaterial().getTitle(), 1, Integer::sum);
        }

        List<Map.Entry<String, Integer>> entries = new ArrayList<>(count.entrySet());
        entries.sort(Map.Entry.<String, Integer>comparingByValue().reversed()
                              .thenComparing(Map.Entry.comparingByKey()));

        Map<String, Integer> top = new LinkedHashMap<>();      // preserves insertion order
        int n = 0;
        for (Map.Entry<String, Integer> e : entries) {
            if (n++ >= howMany) { break; }
            top.put(e.getKey(), e.getValue());
        }
        return top;
    }

    public void report(int currentDay) {
        System.out.println("=== BiblioTech statistics (day " + currentDay + ") ===");

        System.out.println("Loans per employee:");
        loansByEmployee().forEach((e, n) ->
            System.out.printf("  %-16s %d%n", e.getName(), n));

        System.out.println("Fines by material type:");
        totalFineByType(currentDay).forEach((type, fine) ->
            System.out.printf("  %-10s %6.2f EUR%n", type, fine));

        System.out.println("Loans by severity:");
        groupedBySeverity(currentDay).forEach((s, list) ->
            System.out.printf("  %-12s %d loans%n", s, list.size()));

        Employee busiest = busiestEmployee();
        System.out.println("Busiest employee: "
                           + (busiest == null ? "(none)" : busiest.getName()));

        System.out.println("Most borrowed materials:");
        topMaterials(3).forEach((title, n) ->
            System.out.printf("  %-26s %d times%n", title, n));
    }
}