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

Material trobat = index.get("978-0000000001");   // instantani

// Abans: O(n). Amb 50.000 materials, fins a 50.000 comparacions de cadenes.
public Material cercarPerReferencia(String referencia) {
    for (Material m : materials) {
        if (m.getReferencia().equals(referencia)) { return m; }
    }
    return null;
}

// Ara: O(1). Una operacio, sempre, tingui el mapa 10 o 10.000.000 d'entrades.
public Material cercarPerReferencia(String referencia) {
    return index.get(referencia);
}

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

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

Material anterior = index.put("978-0000000001", javaEficac);
System.out.println(anterior);      // null: no hi havia res amb aquesta clau

Material previ = index.put("978-0000000001", altraEdicio);
System.out.println(previ);         // el javaEficac anterior: l'ha SUBSTITUIT

Material m = index.get("978-0000000001");      // el valor, o null si no hi es
Material x = index.get("no-existeix");         // null

// getOrDefault evita el null i tota una familia de comprovacions
int termini = terminisPerTipus.getOrDefault("Audiollibre", 15);   // 15 si no esta registrat

Integer valor = mapa.get(clau);
int resultat = (valor == null) ? 0 : valor;

int resultat = mapa.getOrDefault(clau, 0);

boolean estaCatalogat  = index.containsKey("978-0000000001");   // O(1)
boolean apareixElLlibre = index.containsValue(javaEficac);      // O(n): recorre TOT

Material tret = index.remove("978-0000000001");   // retorna el valor eliminat, o null
boolean haEstatTret = index.remove("978-0000000002", patronsDisseny);  // nomes si coincideix el valor

System.out.println(index.size());         // nombre de parells
System.out.println(index.isEmpty());
index.clear();

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

// 1. Nomes les claus
for (String referencia : index.keySet()) {
    System.out.println(referencia);
}

// 2. Nomes els valors
for (Material m : index.values()) {
    System.out.println(m.getTitol());
}

// 3. Claus I valors: SEMPRE amb entrySet
for (Map.Entry<String, Material> entrada : index.entrySet()) {
    System.out.printf("%-16s -> %s%n", entrada.getKey(), entrada.getValue().getTitol());
}

// INEFICIENT: dues operacions per entrada
for (String referencia : index.keySet()) {
    Material m = index.get(referencia);        // cerca extra, innecessaria
    System.out.println(referencia + " -> " + m.getTitol());
}

for (Map.Entry<String, Integer> e : comptadors.entrySet()) {
    e.setValue(e.getValue() + 1);      // legal i eficient
}

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

index.keySet().remove("978-0000000001");      // elimina l'entrada SENCERA
index.values().removeIf(m -> !m.estaDisponible());   // elimina les entrades els valors de les quals compleixin

// En lloc de:
if (!index.containsKey(ref)) { index.put(ref, material); }

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

// SENSE computeIfAbsent: el patro classic, verbos i facil de trencar
Map<Empleat, List<Prestec>> perEmpleat = new HashMap<>();
for (Prestec p : prestecs) {
    List<Prestec> llista = perEmpleat.get(p.getEmpleat());
    if (llista == null) {
        llista = new ArrayList<>();
        perEmpleat.put(p.getEmpleat(), llista);
    }
    llista.add(p);
}

// AMB computeIfAbsent: una linia
for (Prestec p : prestecs) {
    perEmpleat.computeIfAbsent(p.getEmpleat(), k -> new ArrayList<>()).add(p);
}

Map<String, List<Material>> perTipus = new HashMap<>();
for (Material m : cataleg) {
    perTipus.computeIfAbsent(m.getTipus(), tipus -> new ArrayList<>()).add(m);
}

// SENSE merge
Map<String, Integer> comptadorPerTipus = new HashMap<>();
for (Material m : cataleg) {
    Integer actual = comptadorPerTipus.get(m.getTipus());
    comptadorPerTipus.put(m.getTipus(), (actual == null) ? 1 : actual + 1);
}

// AMB merge
for (Material m : cataleg) {
    comptadorPerTipus.merge(m.getTipus(), 1, Integer::sum);
}

Map<Empleat, Double> multaPerEmpleat = new HashMap<>();
for (Prestec p : prestecs) {
    multaPerEmpleat.merge(p.getEmpleat(), p.calcularMulta(diaActual), Double::sum);
}

Map<String, String> titolsPerTipus = new HashMap<>();
for (Material m : cataleg) {
    titolsPerTipus.merge(m.getTipus(), m.getTitol(), (a, b) -> a + ", " + b);
}

comptadorPerTipus.put(tipus, comptadorPerTipus.getOrDefault(tipus, 0) + 1);

// compute: recalcula SEMPRE, amb el valor actual (que pot ser null)
comptadors.compute("Llibre", (k, v) -> (v == null) ? 1 : v + 1);

// computeIfPresent: nomes actua si la clau JA existeix
inventari.computeIfPresent("978-0000000001", (k, v) -> v - 1);

// Descompta una unitat i elimina l'entrada quan arriba a zero
inventari.computeIfPresent(isbn, (k, v) -> (v <= 1) ? null : v - 1);

tarifes.replaceAll((tipus, tarifa) -> tarifa * 1.10);   // pujada del 10 % a tot

transient Node<K,V>[] table;          // l'array de cubells
transient int size;                   // nombre de parells emmagatzemats
int threshold;                        // capacitat * factor de carrega
final float loadFactor;               // 0.75 per defecte

"978-0000000001".hashCode();     // per exemple, -1234567890

int index = (table.length - 1) & hash;    // equival a hash % 16 quan length es potencia de 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 de la clau -> 2. index de cubell -> 3. mirar en aquell cubell

@Override public int hashCode() { return 42; }    // legal, pero catastrofic

llindar = capacitat × factorDeCarrega

// Malament: 50.000 entrades provoquen uns 12 rehashes, amb recollocacions O(n) cada vegada
Map<String, Material> index = new HashMap<>();

// Be: capacitat suficient des del principi
Map<String, Material> index = new HashMap<>((int) (50_000 / 0.75f) + 1);

package com.nexussoftware.bibliotech.domini;

import java.util.Objects;

/** Clau composta d'un exemplar. equals correcte, hashCode ABSENT. */
public class ClauExemplarTrencada {

    private final String isbn;
    private final int    numeroExemplar;

    public ClauExemplarTrencada(String isbn, int numeroExemplar) {
        this.isbn = isbn;
        this.numeroExemplar = numeroExemplar;
    }

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

    // FALTA hashCode: s'hereta el d'Object, basat en l'adreca de memoria
}

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

System.out.println("c1.equals(c2): " + c1.equals(c2));            // true: son "iguals"
System.out.println("hash c1: " + c1.hashCode());                  // 1735600054  (per exemple)
System.out.println("hash c2: " + c2.hashCode());                  // 21685669    DIFERENT

Map<ClauExemplarTrencada, String> ubicacions = new HashMap<>();
ubicacions.put(c1, "Prestatge A-3");

System.out.println("get(c1): " + ubicacions.get(c1));             // Prestatge A-3
System.out.println("get(c2): " + ubicacions.get(c2));             // null   <-- EL PROBLEMA
System.out.println("containsKey(c2): " + ubicacions.containsKey(c2));  // false
System.out.println("size: " + ubicacions.size());                 // 1

ubicacions.put(c2, "Prestatge B-1");
System.out.println("size despres de posar c2: " + ubicacions.size());  // 2  <-- CLAU DUPLICADA

package com.nexussoftware.bibliotech.domini;

import java.util.Objects;

/** La mateixa clau, amb equals i hashCode COHERENTS. */
public class ClauExemplar {

    private final String isbn;
    private final int    numeroExemplar;

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

    @Override
    public boolean equals(Object o) {
        if (this == o) { return true; }
        if (!(o instanceof ClauExemplar altra)) { return false; }
        return numeroExemplar == altra.numeroExemplar && isbn.equals(altra.isbn);
    }

    /** Els MATEIXOS camps que fa servir equals, ni un mes ni un menys. */
    @Override
    public int hashCode() {
        return Objects.hash(isbn, numeroExemplar);
    }

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

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

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

Map<ClauExemplar, String> ubicacions = new HashMap<>();
ubicacions.put(c1, "Prestatge A-3");

System.out.println("get(c2): " + ubicacions.get(c2));   // Prestatge A-3   <-- FUNCIONA
ubicacions.put(c2, "Prestatge B-1");
System.out.println("size: " + ubicacions.size());       // 1: c2 ha SUBSTITUIT c1

public record ClauExemplarRecord(String isbn, int numeroExemplar) { }   // ja es una clau valida

package com.nexussoftware.bibliotech.domini;

import java.util.Objects;

/** Clau MUTABLE: el camp isbn pot canviar. Mala idea. */
public class ClauMutable {
    private String isbn;                       // NO es final

    public ClauMutable(String isbn) { this.isbn = isbn; }
    public void setIsbn(String isbn) { this.isbn = isbn; }    // el veri

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

ClauMutable clau = new ClauMutable("978-0000000001");
Map<ClauMutable, String> mapa = new HashMap<>();
mapa.put(clau, "Java Eficac");

System.out.println(mapa.get(clau));         // Java Eficac     correcte

clau.setIsbn("978-0000000002");             // MUTEM la clau JA INSERIDA

System.out.println(mapa.get(clau));         // null   <-- l'objecte s'ha perdut
System.out.println(mapa.size());            // 1      <-- pero continua aqui dins
System.out.println(mapa.containsKey(clau)); // false
System.out.println(mapa);                   // {Clau[978-0000000002]=Java Eficac}

List<String> llista = new ArrayList<>(List.of("a", "b"));
Map<List<String>, String> mapa = new HashMap<>();
mapa.put(llista, "valor");

llista.add("c");                        // el hashCode de la llista DEPEN del seu contingut (05-03)
System.out.println(mapa.get(llista));   // null

// Si Empleat tingues equals/hashCode basats en el nom i el nom pogues canviar:
Map<Empleat, List<Prestec>> perEmpleat = new HashMap<>();
perEmpleat.put(marta, prestecsDeMarta);
marta.setNom("Marta Ruiz Garcia");      // catastrofe silenciosa

/** Identifica un exemplar concret: mateix ISBN, diferent numero de copia. */
public record ClauExemplar(String isbn, int numeroExemplar) {
    public ClauExemplar {
        if (isbn == null || isbn.isBlank()) { isbn = "SENSE-ISBN"; }
        if (numeroExemplar < 1) { numeroExemplar = 1; }
    }
}

Map<ClauExemplar, String> ubicacions = new HashMap<>();
ubicacions.put(new ClauExemplar("978-0000000001", 1), "Prestatge A-3");
ubicacions.put(new ClauExemplar("978-0000000001", 2), "Prestatge A-4");

System.out.println(ubicacions.get(new ClauExemplar("978-0000000001", 2)));  // Prestatge A-4

Map<String, Integer> terminis = new LinkedHashMap<>();
terminis.put("Llibre", 15);
terminis.put("Revista", 7);
terminis.put("DVD", 3);

terminis.forEach((tipus, dies) -> System.out.println(tipus + ": " + dies));
// SEMPRE en aquest ordre: Llibre, Revista, DVD

TreeMap<String, Material> perReferencia = new TreeMap<>();
perReferencia.put("978-0000000002", patronsDisseny);
perReferencia.put("978-0000000001", javaEficac);
perReferencia.put("978-0000000003", refactoritzacio);

// Sempre ordenat, sense ordenar res a ma
perReferencia.forEach((k, v) -> System.out.println(k + " -> " + v.getTitol()));

System.out.println(perReferencia.firstKey());        // 978-0000000001
System.out.println(perReferencia.lastKey());         // 978-0000000003
System.out.println(perReferencia.firstEntry());      // parell complet

// Navegacio: NavigableMap
System.out.println(perReferencia.floorKey("978-0000000002x"));   // la clau mes gran <= donada
System.out.println(perReferencia.ceilingKey("978-0000000000"));  // la clau mes petita >= donada
System.out.println(perReferencia.higherKey("978-0000000001"));   // estrictament mes gran
System.out.println(perReferencia.lowerKey("978-0000000003"));    // estrictament mes petita

// Vistes per rang, que son VISTES VIVES del mapa original
SortedMap<String, Material> primers = perReferencia.headMap("978-0000000003");  // < donada
SortedMap<String, Material> ultims  = perReferencia.tailMap("978-0000000002");  // >= donada
NavigableMap<String, Material> tram = perReferencia.subMap("978-0000000001", true,
                                                           "978-0000000002", true);

System.out.println(perReferencia.descendingMap().firstKey());    // recorregut invers

// Ordenat per longitud de la clau i, a igualtat, alfabeticament
Map<String, Integer> aMida = new TreeMap<>(
    Comparator.comparingInt(String::length).thenComparing(Comparator.naturalOrder()));

new LinkedHashMap<>(capacitatInicial, factorDeCarrega, accessOrder);

package com.nexussoftware.bibliotech.servei;

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

/** Cache LRU: conserva les N fitxes consultades mes recentment. */
public class CacheFitxes<K, V> extends LinkedHashMap<K, V> {

    private final int maxim;

    public CacheFitxes(int maxim) {
        super(16, 0.75f, true);      // accessOrder = true: reordena a cada get
        this.maxim = maxim;
    }

    @Override
    protected boolean removeEldestEntry(Map.Entry<K, V> mesAntiga) {
        return size() > maxim;       // si retorna true, LinkedHashMap l'expulsa
    }
}

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

cache.put("978-0000000001", "Java Eficac");
cache.put("978-0000000002", "Patrons de Disseny");
cache.put("978-0000000003", "Refactoritzacio");
System.out.println(cache.keySet());      // [...001, ...002, ...003]

cache.get("978-0000000001");             // consultem el PRIMER: passa al final
System.out.println(cache.keySet());      // [...002, ...003, ...001]

cache.put("978-0000000004", "Codi Net");        // supera el maxim
System.out.println(cache.keySet());      // [...003, ...001, ...004]
// Ha desaparegut ...002: era la menys usada recentment

package com.nexussoftware.bibliotech.servei;

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.domini.Material;

/** Cataleg amb index per referencia: cerques en O(1). */
public class Cataleg {

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

    /** Alta: mante els tres contenidors sincronitzats. */
    public boolean afegir(Material m) {
        if (m == null) { return false; }
        // putIfAbsent retorna el valor existent, o null si ha inserit
        if (perReferencia.putIfAbsent(m.getReferencia(), m) != null) {
            return false;                       // referencia duplicada: alta rebutjada
        }
        materials.add(m);
        perTipus.computeIfAbsent(m.getTipus(), tipus -> new ArrayList<>()).add(m);
        return true;
    }

    /** Cerca per referencia: O(1). Abans era O(n). */
    public Material cercarPerReferencia(String referencia) {
        return perReferencia.get(referencia);
    }

    public boolean estaCatalogat(String referencia) {
        return perReferencia.containsKey(referencia);
    }

    /** Baixa: O(1) per localitzar-lo, O(n) per treure'l de la llista. */
    public boolean eliminar(String referencia) {
        Material m = perReferencia.remove(referencia);
        if (m == null) { return false; }
        materials.remove(m);
        // Si el grup queda buit, l'entrada s'elimina del mapa (funcio que retorna null)
        perTipus.computeIfPresent(m.getTipus(),
                (tipus, llista) -> { llista.remove(m); return llista.isEmpty() ? null : llista; });
        return true;
    }

    /** Tots els materials d'un tipus: O(1). Abans era un recorregut complet. */
    public List<Material> perTipus(String tipus) {
        return List.copyOf(perTipus.getOrDefault(tipus, List.of()));
    }

    /** Informe per tipus: abans eren 20 linies amb bucles imbricats O(n^2). */
    public Map<String, Integer> comptarPerTipus() {
        Map<String, Integer> resum = new HashMap<>();
        for (Material m : materials) {
            resum.merge(m.getTipus(), 1, Integer::sum);
        }
        return resum;
    }

    /** Suma de tarifes diaries agrupada per tipus, tambe amb merge. */
    public Map<String, Double> tarifaTotalPerTipus() {
        Map<String, Double> resum = new HashMap<>();
        for (Material m : materials) {
            resum.merge(m.getTipus(), m.getTarifaDiaria(), Double::sum);
        }
        return resum;
    }

    public List<Material> cercar(Predicate<Material> criteri) {
        List<Material> resultat = new ArrayList<>();
        for (Material m : materials) {
            if (criteri.test(m)) { resultat.add(m); }
        }
        return resultat;
    }

    public void ordenar(Comparator<Material> criteri) { materials.sort(criteri); }
    public List<Material> llistar() { return List.copyOf(materials); }
    public int mida() { return materials.size(); }
}

// ABANS: bucles imbricats, O(n * tipus), 20 linies
public void informePerTipus(Material[] cataleg) {
    String[] tipus = { "Llibre", "Revista", "DVD", "Audiollibre" };
    for (int t = 0; t < tipus.length; t++) {
        int quants = 0;
        double tarifa = 0.0;
        for (int i = 0; i < cataleg.length; i++) {
            if (cataleg[i] != null && cataleg[i].getTipus().equals(tipus[t])) {
                quants++;
                tarifa += cataleg[i].getTarifaDiaria();
            }
        }
        if (quants > 0) {
            System.out.printf("%-12s %3d materials, tarifa mitjana %.2f%n",
                              tipus[t], quants, tarifa / quants);
        }
    }
}

// ARA: una passada, O(n), i sense llista de tipus codificada a ma
public void informePerTipus() {
    Map<String, Integer> quants  = comptarPerTipus();
    Map<String, Double>  tarifes = tarifaTotalPerTipus();
    quants.forEach((tipus, n) ->
        System.out.printf("%-12s %3d materials, tarifa mitjana %.2f%n",
                          tipus, n, tarifes.get(tipus) / n));
}

package com.nexussoftware.bibliotech.servei;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import com.nexussoftware.bibliotech.domini.Empleat;
import com.nexussoftware.bibliotech.domini.Prestec;

public class RegistrePrestecs {

    private final Map<String, Prestec>          perReferencia = new HashMap<>();
    private final Map<Empleat, List<Prestec>>   perEmpleat    = new HashMap<>();

    /**
     * Empleat com a CLAU: exigeix equals/hashCode correctes i basats en un camp
     * IMMUTABLE. A BiblioTech es basen en 'identificador', que es final.
     */
    public void registrar(Prestec p) {
        if (p == null) { return; }
        perReferencia.put(p.getReferencia(), p);
        perEmpleat.computeIfAbsent(p.getEmpleat(), e -> new ArrayList<>()).add(p);
    }

    /** Devolucio en O(1): abans recorria tota la llista de prestecs. */
    public boolean retornar(String referenciaPrestec, int dia) {
        Prestec p = perReferencia.get(referenciaPrestec);
        if (p == null || p.estaRetornat()) { return false; }
        p.registrarDevolucio(dia);
        return true;
    }

    /** Prestecs d'un empleat en O(1): abans era un recorregut complet. */
    public List<Prestec> de(Empleat empleat) {
        return List.copyOf(perEmpleat.getOrDefault(empleat, List.of()));
    }

    /** Multa acumulada per empleat, amb merge. */
    public Map<Empleat, Double> multesPerEmpleat(int diaActual) {
        Map<Empleat, Double> multes = new HashMap<>();
        for (List<Prestec> llista : perEmpleat.values()) {
            for (Prestec p : llista) {
                if (!p.estaRetornat() && p.estaVencut(diaActual)) {
                    multes.merge(p.getEmpleat(), p.calcularMulta(diaActual), Double::sum);
                }
            }
        }
        return multes;
    }

    /** Quants prestecs actius te cada empleat. */
    public Map<Empleat, Integer> actiusPerEmpleat() {
        Map<Empleat, Integer> actius = new HashMap<>();
        for (Map.Entry<Empleat, List<Prestec>> e : perEmpleat.entrySet()) {
            int n = 0;
            for (Prestec p : e.getValue()) {
                if (!p.estaRetornat()) { n++; }
            }
            if (n > 0) { actius.put(e.getKey(), n); }
        }
        return actius;
    }
}

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

Cataleg cataleg = new Cataleg();
cataleg.afegir(new Llibre("Java Eficac",        "Joshua Bloch",  "978-0000000001", 2018));
cataleg.afegir(new Llibre("Patrons de Disseny", "Erich Gamma",   "978-0000000002", 1994));
cataleg.afegir(new Llibre("Refactoritzacio",    "Martin Fowler", "978-0000000003", 1999));
cataleg.afegir(new Revista("Java Magazine",     "REV-2024-03",   42, "Mensual"));
cataleg.afegir(new Dvd("Refactoritzacio en directe", "DVD-0007", 95));

// Cerca instantania, sense recorrer res
Material m = cataleg.cercarPerReferencia("978-0000000002");
System.out.println("Trobat: " + m.getTitol());

System.out.println("--- Informe per tipus ---");
cataleg.comptarPerTipus().forEach((tipus, n) -> System.out.printf("  %-8s %d%n", tipus, n));

RegistrePrestecs registre = new RegistrePrestecs();
registre.registrar(new Prestec(cataleg.cercarPerReferencia("978-0000000001"), marta, 100));
registre.registrar(new Prestec(cataleg.cercarPerReferencia("978-0000000003"), marta, 102));
registre.registrar(new Prestec(cataleg.cercarPerReferencia("DVD-0007"),       diego, 105));

System.out.println("Prestecs de Marta: " + registre.de(marta).size());
System.out.println("--- Multes el dia 130 ---");
registre.multesPerEmpleat(130).forEach((e, multa) ->
    System.out.printf("  %-14s %6.2f EUR%n", e.getNom(), multa));

Trobat: Patrons de Disseny
--- Informe per tipus ---
  Llibre   3
  Revista  1
  DVD      1
Prestecs de Marta: 2
--- Multes el dia 130 ---
  Marta Ruiz      20,00 EUR
  Diego Alonso    12,50 EUR

package com.nexussoftware.bibliotech.servei;

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

/** Index invertit: de cada paraula als materials que la contenen al titol. */
public class IndexCerca {

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

    private static List<String> paraulesDe(Material m) {
        if (m == null || m.getTitol() == null) { return List.of(); }
        List<String> paraules = new ArrayList<>();
        for (String p : m.getTitol().toLowerCase().split("\\s+")) {
            if (p.length() > 2) { paraules.add(p); }   // descartem "de", "el", "la"...
        }
        return paraules;
    }

    public void indexar(Material m) {
        for (String paraula : paraulesDe(m)) {
            // computeIfAbsent: crea la llista NOMES si la paraula es nova,
            // i retorna sempre una llista valida sobre la qual encadenar add
            perParaula.computeIfAbsent(paraula, p -> new ArrayList<>()).add(m);
            // merge: si la paraula es nova guarda 1; si existeix, suma
            frequencia.merge(paraula, 1, Integer::sum);
        }
    }

    /** getOrDefault evita retornar null i les comprovacions de qui crida. */
    public List<Material> cercar(String paraula) {
        if (paraula == null) { return List.of(); }
        return List.copyOf(perParaula.getOrDefault(paraula.toLowerCase(), List.of()));
    }

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

    public List<String> paraulesMesComunes(int quantes) {
        // Aboquem les claus a una llista i l'ordenem per frequencia descendent.
        // Un TreeMap no serviria: ordena per CLAU, no per valor.
        List<String> paraules = new ArrayList<>(frequencia.keySet());
        paraules.sort(Comparator.comparingInt((String p) -> frequencia.get(p)).reversed()
                                .thenComparing(Comparator.naturalOrder()));
        return paraules.subList(0, Math.min(quantes, paraules.size()));
    }

    public void eliminar(Material m) {
        for (String paraula : paraulesDe(m)) {
            // Si la funcio retorna null, computeIfPresent ELIMINA l'entrada del mapa.
            perParaula.computeIfPresent(paraula, (p, llista) -> {
                llista.remove(m);
                return llista.isEmpty() ? null : llista;
            });
            frequencia.computeIfPresent(paraula, (p, n) -> (n <= 1) ? null : n - 1);
        }
    }

    public int paraulesIndexades() { return perParaula.size(); }
}

IndexCerca index = new IndexCerca();
index.indexar(new Llibre("Java Eficac",           "Joshua Bloch",  "978-0000000001", 2018));
index.indexar(new Llibre("Patrons de Disseny",    "Erich Gamma",   "978-0000000002", 1994));
index.indexar(new Llibre("Refactoritzacio",       "Martin Fowler", "978-0000000003", 1999));
index.indexar(new Revista("Java Magazine",        "REV-2024-03",   42, "Mensual"));
index.indexar(new Dvd("Refactoritzacio en directe", "DVD-0007",    95));

System.out.println("Amb 'java': " + index.cercar("java").size());               // 2
System.out.println("Amb 'refactoritzacio': " + index.cercar("refactoritzacio").size()); // 2
System.out.println("Mes comunes: " + index.paraulesMesComunes(3));

package com.nexussoftware.bibliotech.presentacio;

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

public class DemostracioHashCode {

    // --- 1. equals SENSE hashCode ---
    static class ClauTrencada {
        final String isbn;
        ClauTrencada(String isbn) { this.isbn = isbn; }
        @Override public boolean equals(Object o) {
            return (o instanceof ClauTrencada c) && Objects.equals(isbn, c.isbn);
        }
        // sense hashCode: s'hereta el d'Object (basat en identitat)
        @Override public String toString() { return "Trencada[" + isbn + "]"; }
    }

    // --- 2. equals I hashCode coherents ---
    static class ClauCorrecta {
        final String isbn;
        ClauCorrecta(String isbn) { this.isbn = isbn; }
        @Override public boolean equals(Object o) {
            return (o instanceof ClauCorrecta c) && Objects.equals(isbn, c.isbn);
        }
        @Override public int hashCode() { return Objects.hash(isbn); }
        @Override public String toString() { return "Correcta[" + isbn + "]"; }
    }

    // --- 3. clau MUTABLE ---
    static class ClauMutable {
        String isbn;                        // no final: el problema
        ClauMutable(String isbn) { this.isbn = isbn; }
        @Override public boolean equals(Object o) {
            return (o instanceof ClauMutable c) && Objects.equals(isbn, c.isbn);
        }
        @Override public int hashCode() { return Objects.hash(isbn); }
        @Override public String toString() { return "Mutable[" + isbn + "]"; }
    }

    // --- 4. record: equals i hashCode DE FRANC ---
    record ClauRecord(String isbn, int exemplar) { }

    // --- 5. hashCode constant: legal pero catastrofic ---
    static class ClauBeneita {
        final String isbn;
        ClauBeneita(String isbn) { this.isbn = isbn; }
        @Override public boolean equals(Object o) {
            return (o instanceof ClauBeneita c) && Objects.equals(isbn, c.isbn);
        }
        @Override public int hashCode() { return 42; }   // TOTES al mateix cubell
    }

    public static void main(String[] args) {
        demostrarTrencada();
        demostrarCorrecta();
        demostrarMutable();
        demostrarRecord();
        demostrarBeneita();
    }

    static void demostrarTrencada() {
        System.out.println("=== 1. equals SENSE hashCode ===");
        ClauTrencada a = new ClauTrencada("978-0000000001");
        ClauTrencada b = new ClauTrencada("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() + "   <- DIFERENT");

        Map<ClauTrencada, String> mapa = new HashMap<>();
        mapa.put(a, "Prestatge A-3");
        System.out.println("get(a): " + mapa.get(a));                 // Prestatge A-3
        System.out.println("get(b): " + mapa.get(b) + "   <- s'ha PERDUT");

        mapa.put(b, "Prestatge B-1");
        System.out.println("size despres de posar b: " + mapa.size() + "   <- CLAU DUPLICADA");
        System.out.println("Causa: get(b) calcula el hash de b, va a UN ALTRE cubell,");
        System.out.println("       el troba buit i retorna null. equals no es crida MAI.\n");
    }

    static void demostrarCorrecta() {
        System.out.println("=== 2. equals I hashCode ===");
        ClauCorrecta a = new ClauCorrecta("978-0000000001");
        ClauCorrecta b = new ClauCorrecta("978-0000000001");

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

        Map<ClauCorrecta, String> mapa = new HashMap<>();
        mapa.put(a, "Prestatge A-3");
        System.out.println("get(b): " + mapa.get(b) + "   <- FUNCIONA");
        mapa.put(b, "Prestatge B-1");
        System.out.println("size: " + mapa.size() + "   <- b ha SUBSTITUIT a\n");
    }

    static void demostrarMutable() {
        System.out.println("=== 3. clau MUTABLE ===");
        ClauMutable clau = new ClauMutable("978-0000000001");
        Map<ClauMutable, String> mapa = new HashMap<>();
        mapa.put(clau, "Java Eficac");
        System.out.println("get abans de mutar:   " + mapa.get(clau));

        clau.isbn = "978-0000000002";         // mutem la clau JA inserida

        System.out.println("get despres de mutar: " + mapa.get(clau) + "   <- PERDUDA");
        System.out.println("containsKey:          " + mapa.containsKey(clau));
        System.out.println("size:                 " + mapa.size() + "   <- continua aqui dins");
        System.out.println("contingut:            " + mapa);
        System.out.println("L'entrada es al cubell del hash ANTIC. Ningu no la recolloca:");
        System.out.println("es memoria ocupada i irrecuperable, ni tan sols amb remove.\n");
    }

    static void demostrarRecord() {
        System.out.println("=== 4. record ===");
        Map<ClauRecord, String> mapa = new HashMap<>();
        mapa.put(new ClauRecord("978-0000000001", 1), "Prestatge A-3");
        mapa.put(new ClauRecord("978-0000000001", 2), "Prestatge A-4");

        System.out.println("get(nova instancia igual): "
                           + mapa.get(new ClauRecord("978-0000000001", 2)));
        System.out.println("size: " + mapa.size());
        System.out.println("Zero metodes escrits: el record els genera coherents.\n");
    }

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

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

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

        System.out.printf("hashCode ben repartit:   %5d ms%n", msBona);
        System.out.printf("hashCode constant (42):  %5d ms%n", msBeneita);
        System.out.println("Totes les claus cauen al MATEIX cubell. Des de Java 8 aquest");
        System.out.println("cubell es converteix en arbre, aixi que degrada a O(log n) en");
        System.out.println("lloc d'O(n); sense aquesta xarxa de seguretat seria catastrofic.");
    }
}

=== 1. equals SENSE hashCode ===
a.equals(b): true
hash a: 1735600054
hash b: 21685669   <- DIFERENT
get(a): Prestatge A-3
get(b): null   <- s'ha PERDUT
size despres de posar b: 2   <- CLAU DUPLICADA
...
=== 5. hashCode constant ===
hashCode ben repartit:      38 ms
hashCode constant (42):   1420 ms

package com.nexussoftware.bibliotech.servei;

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.domini.Empleat;
import com.nexussoftware.bibliotech.domini.Gravetat;
import com.nexussoftware.bibliotech.domini.Prestec;

public class EstadistiquesBiblioteca {

    private final List<Prestec> prestecs;

    public EstadistiquesBiblioteca(List<Prestec> prestecs) {
        this.prestecs = (prestecs == null) ? List.of() : List.copyOf(prestecs);
    }

    /** merge: el patro comptador en una linia. */
    public Map<Empleat, Integer> prestecsPerEmpleat() {
        Map<Empleat, Integer> resultat = new HashMap<>();
        for (Prestec p : prestecs) {
            resultat.merge(p.getEmpleat(), 1, Integer::sum);
        }
        return resultat;
    }

    /** merge amb Double::sum: acumulador, mateix patro. */
    public Map<String, Double> multaTotalPerTipus(int diaActual) {
        Map<String, Double> resultat = new HashMap<>();
        for (Prestec p : prestecs) {
            double multa = p.calcularMulta(diaActual);
            if (multa > 0) {
                resultat.merge(p.getMaterial().getTipus(), multa, Double::sum);
            }
        }
        return resultat;
    }

    /** computeIfAbsent: el patro mapa de llistes. */
    public Map<Gravetat, List<Prestec>> agrupatsPerGravetat(int diaActual) {
        Map<Gravetat, List<Prestec>> resultat = new HashMap<>();
        for (Prestec p : prestecs) {
            Gravetat g = p.getMaterial().classificarGravetat(diaActual);
            resultat.computeIfAbsent(g, clau -> new ArrayList<>()).add(p);
        }
        return resultat;
        // Nota: amb un enum com a clau, EnumMap seria encara mes eficient.
        // A 10-04 aixo sera Collectors.groupingBy en una sola expressio.
    }

    /** Recorregut d'entrySet per quedar-nos amb el maxim. */
    public Empleat empleatMesActiu() {
        Empleat millor = null;
        int maxim = 0;
        for (Map.Entry<Empleat, Integer> e : prestecsPerEmpleat().entrySet()) {
            if (e.getValue() > maxim) {
                maxim  = e.getValue();
                millor = e.getKey();
            }
        }
        return millor;     // null si no hi ha prestecs
    }

    /**
     * Els N materials mes prestats, EN ORDRE.
     * Un HashMap no conserva ordre, aixi que cal abocar, ordenar i
     * reconstruir en un LinkedHashMap, que si que el conserva.
     */
    public Map<String, Integer> topMaterials(int quants) {
        Map<String, Integer> recompte = new HashMap<>();
        for (Prestec p : prestecs) {
            recompte.merge(p.getMaterial().getTitol(), 1, Integer::sum);
        }

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

        Map<String, Integer> top = new LinkedHashMap<>();     // conserva l'ordre d'insercio
        int n = 0;
        for (Map.Entry<String, Integer> e : entrades) {
            if (n++ >= quants) { break; }
            top.put(e.getKey(), e.getValue());
        }
        return top;
    }

    public void informe(int diaActual) {
        System.out.println("=== Estadistiques de BiblioTech (dia " + diaActual + ") ===");

        System.out.println("Prestecs per empleat:");
        prestecsPerEmpleat().forEach((e, n) ->
            System.out.printf("  %-16s %d%n", e.getNom(), n));

        System.out.println("Multes per tipus de material:");
        multaTotalPerTipus(diaActual).forEach((tipus, multa) ->
            System.out.printf("  %-10s %6.2f EUR%n", tipus, multa));

        System.out.println("Prestecs per gravetat:");
        agrupatsPerGravetat(diaActual).forEach((g, llista) ->
            System.out.printf("  %-12s %d prestecs%n", g, llista.size()));

        Empleat actiu = empleatMesActiu();
        System.out.println("Empleat mes actiu: "
                           + (actiu == null ? "(cap)" : actiu.getNom()));

        System.out.println("Materials mes prestats:");
        topMaterials(3).forEach((titol, n) ->
            System.out.printf("  %-26s %d vegades%n", titol, n));
    }
}