Map<String, Material> indice = new HashMap<>();
indice.put("978-0000000001", javaEfectivo);
indice.put("978-0000000002", patronesDiseno);

Material encontrado = indice.get("978-0000000001");   // instantaneo

// Antes: O(n). Con 50.000 materiales, hasta 50.000 comparaciones de cadenas.
public Material buscarPorReferencia(String referencia) {
    for (Material m : materiales) {
        if (m.getReferencia().equals(referencia)) { return m; }
    }
    return null;
}

// Ahora: O(1). Una operacion, siempre, tenga el mapa 10 o 10.000.000 de entradas.
public Material buscarPorReferencia(String referencia) {
    return indice.get(referencia);
}

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

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

Material anterior = indice.put("978-0000000001", javaEfectivo);
System.out.println(anterior);      // null: no habia nada con esa clave

Material previo = indice.put("978-0000000001", otraEdicion);
System.out.println(previo);        // el javaEfectivo anterior: lo ha SUSTITUIDO

Material m = indice.get("978-0000000001");     // el valor, o null si no esta
Material x = indice.get("no-existe");          // null

// getOrDefault evita el null y toda una familia de comprobaciones
int plazo = plazosPorTipo.getOrDefault("Audiolibro", 15);   // 15 si no esta registrado

Integer valor = mapa.get(clave);
int resultado = (valor == null) ? 0 : valor;

int resultado = mapa.getOrDefault(clave, 0);

boolean estaCatalogado = indice.containsKey("978-0000000001");   // O(1)
boolean apareceElLibro = indice.containsValue(javaEfectivo);     // O(n): recorre TODO

Material quitado = indice.remove("978-0000000001");   // devuelve el valor eliminado, o null
boolean fueQuitado = indice.remove("978-0000000002", patronesDiseno);  // solo si coincide el valor

System.out.println(indice.size());        // numero de pares
System.out.println(indice.isEmpty());
indice.clear();

Map<String, Material> indice = new HashMap<>();
// ... lleno ...

// 1. Solo las claves
for (String referencia : indice.keySet()) {
    System.out.println(referencia);
}

// 2. Solo los valores
for (Material m : indice.values()) {
    System.out.println(m.getTitulo());
}

// 3. Claves Y valores: SIEMPRE con entrySet
for (Map.Entry<String, Material> entrada : indice.entrySet()) {
    System.out.printf("%-16s -> %s%n", entrada.getKey(), entrada.getValue().getTitulo());
}

// INEFICIENTE: dos operaciones por entrada
for (String referencia : indice.keySet()) {
    Material m = indice.get(referencia);       // busqueda extra, innecesaria
    System.out.println(referencia + " -> " + m.getTitulo());
}

for (Map.Entry<String, Integer> e : contadores.entrySet()) {
    e.setValue(e.getValue() + 1);      // legal y eficiente
}

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

indice.keySet().remove("978-0000000001");     // elimina la entrada COMPLETA
indice.values().removeIf(m -> !m.estaDisponible());   // elimina las entradas cuyos valores cumplan

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

// Escribe:
indice.putIfAbsent(ref, material);

// SIN computeIfAbsent: el patron clasico, verboso y facil de romper
Map<Empleado, List<Prestamo>> porEmpleado = new HashMap<>();
for (Prestamo p : prestamos) {
    List<Prestamo> lista = porEmpleado.get(p.getEmpleado());
    if (lista == null) {
        lista = new ArrayList<>();
        porEmpleado.put(p.getEmpleado(), lista);
    }
    lista.add(p);
}

// CON computeIfAbsent: una linea
for (Prestamo p : prestamos) {
    porEmpleado.computeIfAbsent(p.getEmpleado(), k -> new ArrayList<>()).add(p);
}

Map<String, List<Material>> porTipo = new HashMap<>();
for (Material m : catalogo) {
    porTipo.computeIfAbsent(m.getTipo(), tipo -> new ArrayList<>()).add(m);
}

// SIN merge
Map<String, Integer> contadorPorTipo = new HashMap<>();
for (Material m : catalogo) {
    Integer actual = contadorPorTipo.get(m.getTipo());
    contadorPorTipo.put(m.getTipo(), (actual == null) ? 1 : actual + 1);
}

// CON merge
for (Material m : catalogo) {
    contadorPorTipo.merge(m.getTipo(), 1, Integer::sum);
}

Map<Empleado, Double> multaPorEmpleado = new HashMap<>();
for (Prestamo p : prestamos) {
    multaPorEmpleado.merge(p.getEmpleado(), p.calcularMulta(diaActual), Double::sum);
}

Map<String, String> titulosPorTipo = new HashMap<>();
for (Material m : catalogo) {
    titulosPorTipo.merge(m.getTipo(), m.getTitulo(), (a, b) -> a + ", " + b);
}

contadorPorTipo.put(tipo, contadorPorTipo.getOrDefault(tipo, 0) + 1);

// compute: recalcula SIEMPRE, con el valor actual (que puede ser null)
contadores.compute("Libro", (k, v) -> (v == null) ? 1 : v + 1);

// computeIfPresent: solo actua si la clave YA existe
inventario.computeIfPresent("978-0000000001", (k, v) -> v - 1);

// Descuenta una unidad y elimina la entrada cuando llega a cero
inventario.computeIfPresent(isbn, (k, v) -> (v <= 1) ? null : v - 1);

tarifas.replaceAll((tipo, tarifa) -> tarifa * 1.10);    // subida del 10 % a todo

transient Node<K,V>[] table;          // el array de cubetas
transient int size;                   // numero de pares almacenados
int threshold;                        // capacidad * factor de carga
final float loadFactor;               // 0.75 por defecto

"978-0000000001".hashCode();     // por ejemplo, -1234567890

int indice = (table.length - 1) & hash;    // equivale a hash % 16 cuando length es potencia de 2

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

Material m = indice.get("978-0000000001");
// 1. hash de la clave -> 2. indice de cubeta -> 3. mirar en esa cubeta

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

umbral = capacidad × factorDeCarga

// Mal: 50.000 entradas provocan unos 12 rehashes, con recolocaciones O(n) cada vez
Map<String, Material> indice = new HashMap<>();

// Bien: capacidad suficiente desde el principio
Map<String, Material> indice = new HashMap<>((int) (50_000 / 0.75f) + 1);

package com.nexussoftware.bibliotech.dominio;

import java.util.Objects;

/** Clave compuesta de un ejemplar. equals correcto, hashCode AUSENTE. */
public class ClaveEjemplarRota {

    private final String isbn;
    private final int    numeroEjemplar;

    public ClaveEjemplarRota(String isbn, int numeroEjemplar) {
        this.isbn = isbn;
        this.numeroEjemplar = numeroEjemplar;
    }

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

    // FALTA hashCode: se hereda el de Object, basado en la direccion de memoria
}

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

System.out.println("c1.equals(c2): " + c1.equals(c2));            // true: son "iguales"
System.out.println("hash c1: " + c1.hashCode());                  // 1735600054  (por ejemplo)
System.out.println("hash c2: " + c2.hashCode());                  // 21685669    DISTINTO

Map<ClaveEjemplarRota, String> ubicaciones = new HashMap<>();
ubicaciones.put(c1, "Estanteria A-3");

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

ubicaciones.put(c2, "Estanteria B-1");
System.out.println("size tras poner c2: " + ubicaciones.size());  // 2  <-- CLAVE DUPLICADA

package com.nexussoftware.bibliotech.dominio;

import java.util.Objects;

/** La misma clave, con equals y hashCode COHERENTES. */
public class ClaveEjemplar {

    private final String isbn;
    private final int    numeroEjemplar;

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

    @Override
    public boolean equals(Object o) {
        if (this == o) { return true; }
        if (!(o instanceof ClaveEjemplar otra)) { return false; }
        return numeroEjemplar == otra.numeroEjemplar && isbn.equals(otra.isbn);
    }

    /** Los MISMOS campos que usa equals, ni uno mas ni uno menos. */
    @Override
    public int hashCode() {
        return Objects.hash(isbn, numeroEjemplar);
    }

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

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

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

Map<ClaveEjemplar, String> ubicaciones = new HashMap<>();
ubicaciones.put(c1, "Estanteria A-3");

System.out.println("get(c2): " + ubicaciones.get(c2));   // Estanteria A-3   <-- FUNCIONA
ubicaciones.put(c2, "Estanteria B-1");
System.out.println("size: " + ubicaciones.size());       // 1: c2 SUSTITUYO a c1

public record ClaveEjemplarRecord(String isbn, int numeroEjemplar) { }   // ya es una clave valida

package com.nexussoftware.bibliotech.dominio;

import java.util.Objects;

/** Clave MUTABLE: el campo isbn puede cambiar. Mala idea. */
public class ClaveMutable {
    private String isbn;                       // NO es final

    public ClaveMutable(String isbn) { this.isbn = isbn; }
    public void setIsbn(String isbn) { this.isbn = isbn; }    // el veneno

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

ClaveMutable clave = new ClaveMutable("978-0000000001");
Map<ClaveMutable, String> mapa = new HashMap<>();
mapa.put(clave, "Java Efectivo");

System.out.println(mapa.get(clave));        // Java Efectivo    correcto

clave.setIsbn("978-0000000002");            // MUTAMOS la clave YA INSERTADA

System.out.println(mapa.get(clave));        // null   <-- el objeto se ha perdido
System.out.println(mapa.size());            // 1      <-- pero sigue ahi dentro
System.out.println(mapa.containsKey(clave));// false
System.out.println(mapa);                   // {Clave[978-0000000002]=Java Efectivo}

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

lista.add("c");                         // el hashCode de la lista DEPENDE de su contenido (05-03)
System.out.println(mapa.get(lista));    // null

// Si Empleado tuviera equals/hashCode basados en el nombre y el nombre pudiera cambiar:
Map<Empleado, List<Prestamo>> porEmpleado = new HashMap<>();
porEmpleado.put(marta, prestamosDeMarta);
marta.setNombre("Marta Ruiz Garcia");   // catastrofe silenciosa

/** Identifica un ejemplar concreto: mismo ISBN, distinto numero de copia. */
public record ClaveEjemplar(String isbn, int numeroEjemplar) {
    public ClaveEjemplar {
        if (isbn == null || isbn.isBlank()) { isbn = "SIN-ISBN"; }
        if (numeroEjemplar < 1) { numeroEjemplar = 1; }
    }
}

Map<ClaveEjemplar, String> ubicaciones = new HashMap<>();
ubicaciones.put(new ClaveEjemplar("978-0000000001", 1), "Estanteria A-3");
ubicaciones.put(new ClaveEjemplar("978-0000000001", 2), "Estanteria A-4");

System.out.println(ubicaciones.get(new ClaveEjemplar("978-0000000001", 2)));  // Estanteria A-4

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

plazos.forEach((tipo, dias) -> System.out.println(tipo + ": " + dias));
// SIEMPRE en este orden: Libro, Revista, DVD

TreeMap<String, Material> porReferencia = new TreeMap<>();
porReferencia.put("978-0000000002", patronesDiseno);
porReferencia.put("978-0000000001", javaEfectivo);
porReferencia.put("978-0000000003", refactorizacion);

// Siempre ordenado, sin ordenar nada a mano
porReferencia.forEach((k, v) -> System.out.println(k + " -> " + v.getTitulo()));

System.out.println(porReferencia.firstKey());        // 978-0000000001
System.out.println(porReferencia.lastKey());         // 978-0000000003
System.out.println(porReferencia.firstEntry());      // par completo

// Navegacion: NavigableMap
System.out.println(porReferencia.floorKey("978-0000000002x"));   // la mayor clave <= dada
System.out.println(porReferencia.ceilingKey("978-0000000000"));  // la menor clave >= dada
System.out.println(porReferencia.higherKey("978-0000000001"));   // estrictamente mayor
System.out.println(porReferencia.lowerKey("978-0000000003"));    // estrictamente menor

// Vistas por rango, que son VISTAS VIVAS del mapa original
SortedMap<String, Material> primeros = porReferencia.headMap("978-0000000003");  // < dada
SortedMap<String, Material> ultimos  = porReferencia.tailMap("978-0000000002");  // >= dada
NavigableMap<String, Material> tramo = porReferencia.subMap("978-0000000001", true,
                                                            "978-0000000002", true);

System.out.println(porReferencia.descendingMap().firstKey());    // recorrido inverso

// Ordenado por longitud de la clave y, a igualdad, alfabeticamente
Map<String, Integer> aMedida = new TreeMap<>(
    Comparator.comparingInt(String::length).thenComparing(Comparator.naturalOrder()));

new LinkedHashMap<>(capacidadInicial, factorDeCarga, accessOrder);

package com.nexussoftware.bibliotech.servicio;

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

/** Cache LRU: conserva las N fichas consultadas mas recientemente. */
public class CacheFichas<K, V> extends LinkedHashMap<K, V> {

    private final int maximo;

    public CacheFichas(int maximo) {
        super(16, 0.75f, true);      // accessOrder = true: reordena en cada get
        this.maximo = maximo;
    }

    @Override
    protected boolean removeEldestEntry(Map.Entry<K, V> masAntigua) {
        return size() > maximo;      // si devuelve true, LinkedHashMap la expulsa
    }
}

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

cache.put("978-0000000001", "Java Efectivo");
cache.put("978-0000000002", "Patrones de Diseno");
cache.put("978-0000000003", "Refactorizacion");
System.out.println(cache.keySet());      // [...001, ...002, ...003]

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

cache.put("978-0000000004", "Codigo Limpio");   // supera el maximo
System.out.println(cache.keySet());      // [...003, ...001, ...004]
// Ha desaparecido ...002: era la menos usada recientemente

package com.nexussoftware.bibliotech.servicio;

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

/** Catalogo con indice por referencia: busquedas en O(1). */
public class Catalogo {

    private final List<Material>          materiales = new ArrayList<>();
    private final Map<String, Material>   porReferencia = new HashMap<>();
    private final Map<String, List<Material>> porTipo   = new HashMap<>();

    /** Alta: mantiene los tres contenedores sincronizados. */
    public boolean anadir(Material m) {
        if (m == null) { return false; }
        // putIfAbsent devuelve el valor existente, o null si inserto
        if (porReferencia.putIfAbsent(m.getReferencia(), m) != null) {
            return false;                       // referencia duplicada: alta rechazada
        }
        materiales.add(m);
        porTipo.computeIfAbsent(m.getTipo(), tipo -> new ArrayList<>()).add(m);
        return true;
    }

    /** Busqueda por referencia: O(1). Antes era O(n). */
    public Material buscarPorReferencia(String referencia) {
        return porReferencia.get(referencia);
    }

    public boolean estaCatalogado(String referencia) {
        return porReferencia.containsKey(referencia);
    }

    /** Baja: O(1) para localizarlo, O(n) para quitarlo de la lista. */
    public boolean eliminar(String referencia) {
        Material m = porReferencia.remove(referencia);
        if (m == null) { return false; }
        materiales.remove(m);
        // Si el grupo se queda vacio, la entrada se elimina del mapa (funcion que devuelve null)
        porTipo.computeIfPresent(m.getTipo(),
                (tipo, lista) -> { lista.remove(m); return lista.isEmpty() ? null : lista; });
        return true;
    }

    /** Todos los materiales de un tipo: O(1). Antes era un recorrido completo. */
    public List<Material> porTipo(String tipo) {
        return List.copyOf(porTipo.getOrDefault(tipo, List.of()));
    }

    /** Informe por tipo: antes eran 20 lineas con bucles anidados O(n^2). */
    public Map<String, Integer> contarPorTipo() {
        Map<String, Integer> resumen = new HashMap<>();
        for (Material m : materiales) {
            resumen.merge(m.getTipo(), 1, Integer::sum);
        }
        return resumen;
    }

    /** Suma de tarifas diarias agrupada por tipo, tambien con merge. */
    public Map<String, Double> tarifaTotalPorTipo() {
        Map<String, Double> resumen = new HashMap<>();
        for (Material m : materiales) {
            resumen.merge(m.getTipo(), m.getTarifaDiaria(), Double::sum);
        }
        return resumen;
    }

    public List<Material> buscar(Predicate<Material> criterio) {
        List<Material> resultado = new ArrayList<>();
        for (Material m : materiales) {
            if (criterio.test(m)) { resultado.add(m); }
        }
        return resultado;
    }

    public void ordenar(Comparator<Material> criterio) { materiales.sort(criterio); }
    public List<Material> listar() { return List.copyOf(materiales); }
    public int tamano() { return materiales.size(); }
}

// ANTES: bucles anidados, O(n * tipos), 20 lineas
public void informePorTipo(Material[] catalogo) {
    String[] tipos = { "Libro", "Revista", "DVD", "Audiolibro" };
    for (int t = 0; t < tipos.length; t++) {
        int cuantos = 0;
        double tarifa = 0.0;
        for (int i = 0; i < catalogo.length; i++) {
            if (catalogo[i] != null && catalogo[i].getTipo().equals(tipos[t])) {
                cuantos++;
                tarifa += catalogo[i].getTarifaDiaria();
            }
        }
        if (cuantos > 0) {
            System.out.printf("%-12s %3d materiales, tarifa media %.2f%n",
                              tipos[t], cuantos, tarifa / cuantos);
        }
    }
}

// AHORA: una pasada, O(n), y sin lista de tipos codificada a mano
public void informePorTipo() {
    Map<String, Integer> cuantos = contarPorTipo();
    Map<String, Double>  tarifas = tarifaTotalPorTipo();
    cuantos.forEach((tipo, n) ->
        System.out.printf("%-12s %3d materiales, tarifa media %.2f%n",
                          tipo, n, tarifas.get(tipo) / n));
}

package com.nexussoftware.bibliotech.servicio;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import com.nexussoftware.bibliotech.dominio.Empleado;
import com.nexussoftware.bibliotech.dominio.Prestamo;

public class RegistroPrestamos {

    private final Map<String, Prestamo>          porReferencia = new HashMap<>();
    private final Map<Empleado, List<Prestamo>>  porEmpleado   = new HashMap<>();

    /**
     * Empleado como CLAVE: exige equals/hashCode correctos y basados en un campo
     * INMUTABLE. En BiblioTech se basan en 'identificador', que es final.
     */
    public void registrar(Prestamo p) {
        if (p == null) { return; }
        porReferencia.put(p.getReferencia(), p);
        porEmpleado.computeIfAbsent(p.getEmpleado(), e -> new ArrayList<>()).add(p);
    }

    /** Devolucion en O(1): antes recorria toda la lista de prestamos. */
    public boolean devolver(String referenciaPrestamo, int dia) {
        Prestamo p = porReferencia.get(referenciaPrestamo);
        if (p == null || p.estaDevuelto()) { return false; }
        p.registrarDevolucion(dia);
        return true;
    }

    /** Prestamos de un empleado en O(1): antes era un recorrido completo. */
    public List<Prestamo> de(Empleado empleado) {
        return List.copyOf(porEmpleado.getOrDefault(empleado, List.of()));
    }

    /** Multa acumulada por empleado, con merge. */
    public Map<Empleado, Double> multasPorEmpleado(int diaActual) {
        Map<Empleado, Double> multas = new HashMap<>();
        for (List<Prestamo> lista : porEmpleado.values()) {
            for (Prestamo p : lista) {
                if (!p.estaDevuelto() && p.estaVencido(diaActual)) {
                    multas.merge(p.getEmpleado(), p.calcularMulta(diaActual), Double::sum);
                }
            }
        }
        return multas;
    }

    /** Cuantos prestamos activos tiene cada empleado. */
    public Map<Empleado, Integer> activosPorEmpleado() {
        Map<Empleado, Integer> activos = new HashMap<>();
        for (Map.Entry<Empleado, List<Prestamo>> e : porEmpleado.entrySet()) {
            int n = 0;
            for (Prestamo p : e.getValue()) {
                if (!p.estaDevuelto()) { n++; }
            }
            if (n > 0) { activos.put(e.getKey(), n); }
        }
        return activos;
    }
}

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

Catalogo catalogo = new Catalogo();
catalogo.anadir(new Libro("Java Efectivo",      "Joshua Bloch",  "978-0000000001", 2018));
catalogo.anadir(new Libro("Patrones de Diseno", "Erich Gamma",   "978-0000000002", 1994));
catalogo.anadir(new Libro("Refactorizacion",    "Martin Fowler", "978-0000000003", 1999));
catalogo.anadir(new Revista("Java Magazine",    "REV-2024-03",   42, "Mensual"));
catalogo.anadir(new Dvd("Refactorizacion en vivo", "DVD-0007",   95));

// Busqueda instantanea, sin recorrer nada
Material m = catalogo.buscarPorReferencia("978-0000000002");
System.out.println("Encontrado: " + m.getTitulo());

System.out.println("--- Informe por tipo ---");
catalogo.contarPorTipo().forEach((tipo, n) -> System.out.printf("  %-8s %d%n", tipo, n));

RegistroPrestamos registro = new RegistroPrestamos();
registro.registrar(new Prestamo(catalogo.buscarPorReferencia("978-0000000001"), marta, 100));
registro.registrar(new Prestamo(catalogo.buscarPorReferencia("978-0000000003"), marta, 102));
registro.registrar(new Prestamo(catalogo.buscarPorReferencia("DVD-0007"),       diego, 105));

System.out.println("Prestamos de Marta: " + registro.de(marta).size());
System.out.println("--- Multas en el dia 130 ---");
registro.multasPorEmpleado(130).forEach((e, multa) ->
    System.out.printf("  %-14s %6.2f EUR%n", e.getNombre(), multa));

Encontrado: Patrones de Diseno
--- Informe por tipo ---
  Libro    3
  Revista  1
  DVD      1
Prestamos de Marta: 2
--- Multas en el dia 130 ---
  Marta Ruiz      20,00 EUR
  Diego Alonso    12,50 EUR

package com.nexussoftware.bibliotech.servicio;

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

/** Indice invertido: de cada palabra a los materiales que la contienen en el titulo. */
public class IndiceBusqueda {

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

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

    public void indexar(Material m) {
        for (String palabra : palabrasDe(m)) {
            // computeIfAbsent: crea la lista SOLO si la palabra es nueva,
            // y devuelve siempre una lista valida sobre la que encadenar add
            porPalabra.computeIfAbsent(palabra, p -> new ArrayList<>()).add(m);
            // merge: si la palabra es nueva guarda 1; si existe, suma
            frecuencia.merge(palabra, 1, Integer::sum);
        }
    }

    /** getOrDefault evita devolver null y las comprobaciones de quien llama. */
    public List<Material> buscar(String palabra) {
        if (palabra == null) { return List.of(); }
        return List.copyOf(porPalabra.getOrDefault(palabra.toLowerCase(), List.of()));
    }

    public Map<String, Integer> frecuencias() {
        return Map.copyOf(frecuencia);        // copia inmutable
    }

    public List<String> palabrasMasComunes(int cuantas) {
        // Volcamos las claves a una lista y la ordenamos por frecuencia descendente.
        // Un TreeMap no serviria: ordena por CLAVE, no por valor.
        List<String> palabras = new ArrayList<>(frecuencia.keySet());
        palabras.sort(Comparator.comparingInt((String p) -> frecuencia.get(p)).reversed()
                                .thenComparing(Comparator.naturalOrder()));
        return palabras.subList(0, Math.min(cuantas, palabras.size()));
    }

    public void eliminar(Material m) {
        for (String palabra : palabrasDe(m)) {
            // Si la funcion devuelve null, computeIfPresent ELIMINA la entrada del mapa.
            porPalabra.computeIfPresent(palabra, (p, lista) -> {
                lista.remove(m);
                return lista.isEmpty() ? null : lista;
            });
            frecuencia.computeIfPresent(palabra, (p, n) -> (n <= 1) ? null : n - 1);
        }
    }

    public int palabrasIndexadas() { return porPalabra.size(); }
}

IndiceBusqueda indice = new IndiceBusqueda();
indice.indexar(new Libro("Java Efectivo",         "Joshua Bloch",  "978-0000000001", 2018));
indice.indexar(new Libro("Patrones de Diseno",    "Erich Gamma",   "978-0000000002", 1994));
indice.indexar(new Libro("Refactorizacion",       "Martin Fowler", "978-0000000003", 1999));
indice.indexar(new Revista("Java Magazine",       "REV-2024-03",   42, "Mensual"));
indice.indexar(new Dvd("Refactorizacion en vivo", "DVD-0007",      95));

System.out.println("Con 'java': " + indice.buscar("java").size());               // 2
System.out.println("Con 'refactorizacion': " + indice.buscar("refactorizacion").size()); // 2
System.out.println("Mas comunes: " + indice.palabrasMasComunes(3));

package com.nexussoftware.bibliotech.presentacion;

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

public class DemostracionHashCode {

    // --- 1. equals SIN hashCode ---
    static class ClaveRota {
        final String isbn;
        ClaveRota(String isbn) { this.isbn = isbn; }
        @Override public boolean equals(Object o) {
            return (o instanceof ClaveRota c) && Objects.equals(isbn, c.isbn);
        }
        // sin hashCode: se hereda el de Object (basado en identidad)
        @Override public String toString() { return "Rota[" + isbn + "]"; }
    }

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

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

    // --- 4. record: equals y hashCode GRATIS ---
    record ClaveRecord(String isbn, int ejemplar) { }

    // --- 5. hashCode constante: legal pero catastrofico ---
    static class ClaveTonta {
        final String isbn;
        ClaveTonta(String isbn) { this.isbn = isbn; }
        @Override public boolean equals(Object o) {
            return (o instanceof ClaveTonta c) && Objects.equals(isbn, c.isbn);
        }
        @Override public int hashCode() { return 42; }   // TODAS en la misma cubeta
    }

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

    static void demostrarRota() {
        System.out.println("=== 1. equals SIN hashCode ===");
        ClaveRota a = new ClaveRota("978-0000000001");
        ClaveRota b = new ClaveRota("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() + "   <- DISTINTO");

        Map<ClaveRota, String> mapa = new HashMap<>();
        mapa.put(a, "Estanteria A-3");
        System.out.println("get(a): " + mapa.get(a));                 // Estanteria A-3
        System.out.println("get(b): " + mapa.get(b) + "   <- se ha PERDIDO");

        mapa.put(b, "Estanteria B-1");
        System.out.println("size tras poner b: " + mapa.size() + "   <- CLAVE DUPLICADA");
        System.out.println("Causa: get(b) calcula el hash de b, va a OTRA cubeta,");
        System.out.println("       la encuentra vacia y devuelve null. equals NUNCA se llama.\n");
    }

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

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

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

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

        clave.isbn = "978-0000000002";        // mutamos la clave YA insertada

        System.out.println("get tras mutar:     " + mapa.get(clave) + "   <- PERDIDA");
        System.out.println("containsKey:        " + mapa.containsKey(clave));
        System.out.println("size:               " + mapa.size() + "   <- sigue ahi dentro");
        System.out.println("contenido:          " + mapa);
        System.out.println("La entrada esta en la cubeta del hash ANTIGUO. Nadie la recoloca:");
        System.out.println("es memoria ocupada e irrecuperable, ni siquiera con remove.\n");
    }

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

        System.out.println("get(nueva instancia igual): "
                           + mapa.get(new ClaveRecord("978-0000000001", 2)));
        System.out.println("size: " + mapa.size());
        System.out.println("Cero metodos escritos: el record los genera coherentes.\n");
    }

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

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

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

        System.out.printf("hashCode bien repartido: %5d ms%n", msBuena);
        System.out.printf("hashCode constante (42): %5d ms%n", msTonta);
        System.out.println("Todas las claves caen en la MISMA cubeta. Desde Java 8 esa");
        System.out.println("cubeta se convierte en arbol, asi que degrada a O(log n) en");
        System.out.println("vez de O(n); sin esa red de seguridad seria catastrofico.");
    }
}

=== 1. equals SIN hashCode ===
a.equals(b): true
hash a: 1735600054
hash b: 21685669   <- DISTINTO
get(a): Estanteria A-3
get(b): null   <- se ha PERDIDO
size tras poner b: 2   <- CLAVE DUPLICADA
...
=== 5. hashCode constante ===
hashCode bien repartido:    38 ms
hashCode constante (42):  1420 ms

package com.nexussoftware.bibliotech.servicio;

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.dominio.Empleado;
import com.nexussoftware.bibliotech.dominio.Gravedad;
import com.nexussoftware.bibliotech.dominio.Prestamo;

public class EstadisticasBiblioteca {

    private final List<Prestamo> prestamos;

    public EstadisticasBiblioteca(List<Prestamo> prestamos) {
        this.prestamos = (prestamos == null) ? List.of() : List.copyOf(prestamos);
    }

    /** merge: el patron contador en una linea. */
    public Map<Empleado, Integer> prestamosPorEmpleado() {
        Map<Empleado, Integer> resultado = new HashMap<>();
        for (Prestamo p : prestamos) {
            resultado.merge(p.getEmpleado(), 1, Integer::sum);
        }
        return resultado;
    }

    /** merge con Double::sum: acumulador, mismo patron. */
    public Map<String, Double> multaTotalPorTipo(int diaActual) {
        Map<String, Double> resultado = new HashMap<>();
        for (Prestamo p : prestamos) {
            double multa = p.calcularMulta(diaActual);
            if (multa > 0) {
                resultado.merge(p.getMaterial().getTipo(), multa, Double::sum);
            }
        }
        return resultado;
    }

    /** computeIfAbsent: el patron mapa de listas. */
    public Map<Gravedad, List<Prestamo>> agrupadosPorGravedad(int diaActual) {
        Map<Gravedad, List<Prestamo>> resultado = new HashMap<>();
        for (Prestamo p : prestamos) {
            Gravedad g = p.getMaterial().clasificarGravedad(diaActual);
            resultado.computeIfAbsent(g, clave -> new ArrayList<>()).add(p);
        }
        return resultado;
        // Nota: con un enum como clave, EnumMap seria aun mas eficiente.
        // En 10-04 esto sera Collectors.groupingBy en una sola expresion.
    }

    /** Recorrido de entrySet para quedarnos con el maximo. */
    public Empleado empleadoMasActivo() {
        Empleado mejor = null;
        int maximo = 0;
        for (Map.Entry<Empleado, Integer> e : prestamosPorEmpleado().entrySet()) {
            if (e.getValue() > maximo) {
                maximo = e.getValue();
                mejor  = e.getKey();
            }
        }
        return mejor;      // null si no hay prestamos
    }

    /**
     * Los N materiales mas prestados, EN ORDEN.
     * Un HashMap no conserva orden, asi que hay que volcar, ordenar y
     * reconstruir en un LinkedHashMap, que si lo conserva.
     */
    public Map<String, Integer> topMateriales(int cuantos) {
        Map<String, Integer> conteo = new HashMap<>();
        for (Prestamo p : prestamos) {
            conteo.merge(p.getMaterial().getTitulo(), 1, Integer::sum);
        }

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

        Map<String, Integer> top = new LinkedHashMap<>();     // conserva el orden de insercion
        int n = 0;
        for (Map.Entry<String, Integer> e : entradas) {
            if (n++ >= cuantos) { break; }
            top.put(e.getKey(), e.getValue());
        }
        return top;
    }

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

        System.out.println("Prestamos por empleado:");
        prestamosPorEmpleado().forEach((e, n) ->
            System.out.printf("  %-16s %d%n", e.getNombre(), n));

        System.out.println("Multas por tipo de material:");
        multaTotalPorTipo(diaActual).forEach((tipo, multa) ->
            System.out.printf("  %-10s %6.2f EUR%n", tipo, multa));

        System.out.println("Prestamos por gravedad:");
        agrupadosPorGravedad(diaActual).forEach((g, lista) ->
            System.out.printf("  %-12s %d prestamos%n", g, lista.size()));

        Empleado activo = empleadoMasActivo();
        System.out.println("Empleado mas activo: "
                           + (activo == null ? "(ninguno)" : activo.getNombre()));

        System.out.println("Materiales mas prestados:");
        topMateriales(3).forEach((titulo, n) ->
            System.out.printf("  %-26s %d veces%n", titulo, n));
    }
}