import java.util.ArrayList;
import java.util.List;

public class CatalogoAntiguo {

    public static void main(String[] args) {
        List catalogo = new ArrayList();   // sin genericos: guarda Object

        catalogo.add(new Libro("Java Efectivo", "978-0000000001"));
        catalogo.add(new Libro("Patrones de Diseño", "978-0000000002"));
        catalogo.add("Refactorización");   // ¡ERROR! pero el compilador calla

        for (int i = 0; i < catalogo.size(); i++) {
            Libro libro = (Libro) catalogo.get(i);   // cast obligatorio
            System.out.println(libro.getTitulo());
        }
    }
}

Java Efectivo
Patrones de Diseño
Exception in thread "main" java.lang.ClassCastException:
    class java.lang.String cannot be cast to class Libro
    at CatalogoAntiguo.main(CatalogoAntiguo.java:14)

import java.util.ArrayList;
import java.util.List;

public class CatalogoModerno {

    public static void main(String[] args) {
        List<Libro> catalogo = new ArrayList<>();

        catalogo.add(new Libro("Java Efectivo", "978-0000000001"));
        catalogo.add(new Libro("Patrones de Diseño", "978-0000000002"));
        // catalogo.add("Refactorización");   // NO COMPILA

        for (Libro libro : catalogo) {        // sin cast
            System.out.println(libro.getTitulo());
        }
    }
}

error: no suitable method found for add(String)
    catalogo.add("Refactorización");
            ^
    method Collection.add(Libro) is not applicable
      (argument mismatch; String cannot be converted to Libro)

package com.nexussoftware.bibliotech.dominio;

/**
 * Contenedor de un unico valor de tipo T.
 * T es un PARAMETRO DE TIPO: no existe hasta que alguien
 * escribe Caja<Libro> o Caja<String>.
 */
public class Caja<T> {

    private T contenido;          // campo del tipo parametrizado

    public Caja(T contenido) {    // parametro del tipo parametrizado
        this.contenido = contenido;
    }

    public T obtener() {          // retorno del tipo parametrizado
        return contenido;
    }

    public void guardar(T contenido) {
        this.contenido = contenido;
    }

    public boolean estaVacia() {
        return contenido == null;
    }

    @Override
    public String toString() {
        return "Caja[" + contenido + "]";
    }
}

Caja<Libro> cajaLibro = new Caja<>(new Libro("Java Efectivo", "978-0000000001"));
Libro l = cajaLibro.obtener();      // sin cast: el compilador sabe que es Libro

Caja<String> cajaTexto = new Caja<>("Sala 3");
String s = cajaTexto.obtener();

// cajaLibro.guardar("esto no");    // NO COMPILA

/**
 * Par de valores de tipos posiblemente distintos.
 * Es, en esencia, lo que hace Map.Entry<K, V>.
 */
public class Par<A, B> {

    private final A primero;
    private final B segundo;

    public Par(A primero, B segundo) {
        this.primero = primero;
        this.segundo = segundo;
    }

    public A primero()  { return primero; }
    public B segundo()  { return segundo; }

    /** Devuelve el par con los elementos intercambiados. */
    public Par<B, A> invertir() {
        return new Par<>(segundo, primero);
    }

    @Override
    public String toString() {
        return "(" + primero + ", " + segundo + ")";
    }
}

Par<String, Integer> prestamosPorEmpleado = new Par<>("Marta Ruiz", 4);
Par<Integer, String> invertido = prestamosPorEmpleado.invertir();
System.out.println(prestamosPorEmpleado);   // (Marta Ruiz, 4)
System.out.println(invertido);              // (4, Marta Ruiz)

Map<String, List<Prestamo>> porEmpleado = new HashMap<String, List<Prestamo>>();

Map<String, List<Prestamo>> porEmpleado = new HashMap<>();

var catalogo = new ArrayList<Libro>();    // BIEN: el tipo va a la derecha
// var lista = new ArrayList<>();         // infiere ArrayList<Object>: casi nunca es lo que quieres

Comparator<Libro> porTitulo = new Comparator<>() {   // Java 9+
    @Override
    public int compare(Libro a, Libro b) {
        return a.getTitulo().compareTo(b.getTitulo());
    }
};

package com.nexussoftware.bibliotech.dominio;

/**
 * Todo lo que BiblioTech puede almacenar en un repositorio
 * sabe decir cual es su identificador.
 */
public interface Identificable {
    String getId();
}

package com.nexussoftware.bibliotech.servicio;

/**
 * Convierte objetos de tipo T en una linea de texto y viceversa.
 * Sustituye a los metodos aTexto/desdeTexto repetidos en el modulo 7.
 */
public interface Serializador<T> {

    String serializar(T objeto);

    T deserializar(String linea);
}

// FORMA 1: fijar el tipo. La implementacion ya NO es generica.
public class SerializadorLibro implements Serializador<Libro> {

    @Override
    public String serializar(Libro libro) {
        return libro.getIsbn() + ";" + libro.getTitulo();
    }

    @Override
    public Libro deserializar(String linea) {
        String[] partes = linea.split(";", 2);
        return new Libro(partes[1], partes[0]);
    }
}

// FORMA 2: propagar el parametro. La implementacion sigue siendo generica.
public class SerializadorConRegistro<T> implements Serializador<T> {

    private final Serializador<T> delegado;

    public SerializadorConRegistro(Serializador<T> delegado) {
        this.delegado = delegado;
    }

    @Override
    public String serializar(T objeto) {
        String resultado = delegado.serializar(objeto);
        System.out.println("[SER] " + objeto.getClass().getSimpleName());
        return resultado;
    }

    @Override
    public T deserializar(String linea) {
        return delegado.deserializar(linea);
    }
}

public class Utilidades {

    /**
     * Intercambia dos posiciones de una lista de cualquier tipo.
     *   modificadores  <T>  retorno  nombre
     */
    public static <T> void intercambiar(List<T> lista, int i, int j) {
        T temporal = lista.get(i);
        lista.set(i, lista.get(j));
        lista.set(j, temporal);
    }

    /** Devuelve el primer elemento o null si la lista esta vacia. */
    public static <T> T primero(List<T> lista) {
        return lista.isEmpty() ? null : lista.get(0);
    }

    /** Construye una lista a partir de elementos sueltos. */
    @SafeVarargs
    public static <T> List<T> listaDe(T... elementos) {
        return new ArrayList<>(Arrays.asList(elementos));
    }

    /** Cuenta cuantos elementos de la lista cumplen el predicado. */
    public static <T> long contar(List<T> lista, Predicate<T> criterio) {
        long total = 0;
        for (T elemento : lista) {
            if (criterio.test(elemento)) {
                total++;
            }
        }
        return total;
    }
}

List<Libro> catalogo = Utilidades.listaDe(
        new Libro("Java Efectivo", "978-0000000001"),
        new Libro("Refactorización", "978-0000000003"));

Utilidades.intercambiar(catalogo, 0, 1);         // T se infiere: Libro
Libro primero = Utilidades.primero(catalogo);     // T se infiere: Libro

long prestados = Utilidades.contar(catalogo, Libro::estaPrestado);

List<Material> vacia = Utilidades.<Material>listaDe();   // sin argumentos no hay nada que inferir

public class Caja<T> {
    // ERROR: non-static type variable T cannot be referenced from a static context
    public static T crearVacia() { return null; }
}

public static <U> Caja<U> crearVacia() {
    return new Caja<>(null);
}

/**
 * Devuelve el mayor elemento de la lista.
 * T DEBE saber compararse consigo mismo.
 */
public static <T extends Comparable<T>> T maximo(List<T> lista) {
    if (lista.isEmpty()) {
        throw new IllegalArgumentException("lista vacía");
    }
    T mayor = lista.get(0);
    for (T elemento : lista) {
        if (elemento.compareTo(mayor) > 0) {   // legal SOLO gracias al limite
            mayor = elemento;
        }
    }
    return mayor;
}

/** Concatena los titulos de cualquier coleccion de materiales. */
public static <T extends Material> String titulos(List<T> materiales) {
    StringBuilder sb = new StringBuilder();
    for (T m : materiales) {
        sb.append(m.getTitulo()).append("; ");   // getTitulo() es de Material
    }
    return sb.toString();
}

/**
 * Ordena e imprime elementos que ademas de comparables
 * saben serializarse.
 */
public static <T extends Comparable<T> & Serializable> void archivarOrdenado(List<T> items) {
    Collections.sort(items);
    for (T item : items) {
        System.out.println("Archivando: " + item);
    }
}

public static <T extends Material & Comparable<T>> List<T> ordenarCatalogo(List<T> materiales) {
    List<T> copia = new ArrayList<>(materiales);
    Collections.sort(copia);
    return copia;
}

List<String> textos = new ArrayList<>();
// List<Object> objetos = textos;    // NO COMPILA

List<String> textos = new ArrayList<>();
List<Object> objetos = textos;        // supongamos que esto compilara
objetos.add(Integer.valueOf(42));     // legal: un Integer ES un Object
String s = textos.get(0);             // BOOM: ClassCastException en ejecucion

public class CovarianciaDeArrays {

    public static void main(String[] args) {
        String[] textos = { "Java Efectivo", "Refactorización" };
        Object[] objetos = textos;          // COMPILA: los arrays son covariantes

        objetos[0] = Integer.valueOf(42);   // compila... y explota en ejecucion
        System.out.println(textos[0]);
    }
}

Exception in thread "main" java.lang.ArrayStoreException: java.lang.Integer
    at CovarianciaDeArrays.main(CovarianciaDeArrays.java:8)

public static void imprimirTitulos(List<Material> materiales) {
    for (Material m : materiales) {
        System.out.println(m.getTitulo());
    }
}

/** Sirve para CUALQUIER lista: solo usa metodos que no dependen de T. */
public static void informarTamano(List<?> lista) {
    System.out.println("La lista tiene " + lista.size() + " elementos");
    for (Object o : lista) {         // lo unico seguro es leer como Object
        System.out.println("  - " + o);
    }
}

informarTamano(List.of("a", "b"));                   // List<String>
informarTamano(List.of(new Libro("Java Efectivo", "978-0000000001")));  // List<Libro>

public static void intentarAnadir(List<?> lista) {
    // lista.add("hola");     // NO COMPILA
    // lista.add(new Object()); // NO COMPILA
    lista.add(null);            // unico permitido
}

public static void imprimirTitulos(List<? extends Material> materiales) {
    for (Material m : materiales) {      // leer como Material: SEGURO
        System.out.println(m.getTitulo());
    }
    // materiales.add(new Libro(...));   // NO COMPILA
}

List<Libro> libros = new ArrayList<>();
List<Revista> revistas = new ArrayList<>();
List<Material> mezcla = new ArrayList<>();

imprimirTitulos(libros);     // OK
imprimirTitulos(revistas);   // OK
imprimirTitulos(mezcla);     // OK

public static void anadirLibrosDePrueba(List<? super Libro> destino) {
    destino.add(new Libro("Java Efectivo", "978-0000000001"));   // SEGURO
    destino.add(new Libro("Refactorización", "978-0000000003"));

    // Libro l = destino.get(0);    // NO COMPILA
    Object o = destino.get(0);      // lo unico seguro es Object
}

List<Libro> soloLibros = new ArrayList<>();
List<Material> materiales = new ArrayList<>();
List<Object> cualquiera = new ArrayList<>();

anadirLibrosDePrueba(soloLibros);   // OK
anadirLibrosDePrueba(materiales);   // OK
anadirLibrosDePrueba(cualquiera);   // OK

/**
 * Copia elementos de origen a destino.
 *   origen  PRODUCE elementos -> ? extends T
 *   destino CONSUME elementos -> ? super T
 */
public static <T> void copiar(List<? extends T> origen, List<? super T> destino) {
    for (T elemento : origen) {
        destino.add(elemento);
    }
}

List<Libro> libros = List.of(
        new Libro("Java Efectivo", "978-0000000001"),
        new Libro("Patrones de Diseño", "978-0000000002"));

List<Material> almacen = new ArrayList<>();
List<Object> registro   = new ArrayList<>();

Utilidades.<Material>copiar(libros, almacen);   // Libro produce, Material consume
Utilidades.<Libro>copiar(libros, registro);     // Libro produce, Object consume

// MAL: destino declarado como productor
public static <T> void copiarMal(List<? extends T> origen, List<? extends T> destino) {
    for (T elemento : origen) {
        destino.add(elemento);   // NO COMPILA
    }
}

error: no suitable method found for add(T)
    destino.add(elemento);
           ^
    method Collection.add(CAP#1) is not applicable
      (argument mismatch; T cannot be converted to CAP#1)

// MAL: origen declarado como consumidor
public static <T> void copiarMal2(List<? super T> origen, List<? super T> destino) {
    for (T elemento : origen) {   // NO COMPILA
        destino.add(elemento);
    }
}

error: incompatible types: CAP#1 cannot be converted to T

// Collections: origen produce, destino consume
public static <T> void copy(List<? super T> dest, List<? extends T> src)

// El comparador CONSUME elementos para compararlos
public static <T> void sort(List<T> list, Comparator<? super T> c)

// Stream.map: la funcion CONSUME T y PRODUCE R
<R> Stream<R> map(Function<? super T, ? extends R> mapper)

// Optional.ifPresent: el consumidor CONSUME T
public void ifPresent(Consumer<? super T> action)

Comparator<Material> porTitulo = Comparator.comparing(Material::getTitulo);

List<Libro> libros = new ArrayList<>(...);
libros.sort(porTitulo);    // funciona gracias al ? super T

public class Caja<T> {
    private T contenido;
    public T obtener() { return contenido; }
    public void guardar(T c) { this.contenido = c; }
}

public class Caja {
    private Object contenido;
    public Object obtener() { return contenido; }
    public void guardar(Object c) { this.contenido = c; }
}

Caja<Libro> caja = new Caja<>(libro);
Libro l = caja.obtener();

Caja caja = new Caja(libro);
Libro l = (Libro) caja.obtener();   // el cast lo pone el compilador

public static <T extends Material> String titulos(List<T> lista)
// se borra a
public static String titulos(List lista)   // y dentro, T se trata como Material

javac Caja.java
javap -p Caja.class

public class Caja<T> {
  private T contenido;
  public Caja(T);
  public T obtener();
  public void guardar(T);
}

public class Repositorio<T> {
    public T crearVacio() {
        // return new T();   // ERROR: type parameter T cannot be instantiated directly
        return null;
    }
}

public class Repositorio<T> {

    private final Supplier<T> fabrica;

    public Repositorio(Supplier<T> fabrica) {
        this.fabrica = fabrica;
    }

    public T crearVacio() {
        return fabrica.get();      // la fabrica SI sabe construir un T
    }
}

// uso
Repositorio<Libro> repo = new Repositorio<>(Libro::new);

if (objeto instanceof List<String>) { }   // ERROR: illegal generic type for instanceof
if (objeto instanceof List<?>) { }        // OK: solo el tipo crudo es comprobable

public class Informes {
    // ERROR: name clash: ambos se borran a  procesar(List)
    public void procesar(List<Libro> libros) { }
    public void procesar(List<Revista> revistas) { }
}

error: name clash: procesar(List<Revista>) and procesar(List<Libro>) have the same erasure

public class Repositorio<T> {
    // private T[] items = new T[10];   // ERROR: generic array creation
}

// SOLUCION 1 (recomendada): usar una List
private final List<T> items = new ArrayList<>();

// SOLUCION 2: array de Object con cast y aviso suprimido (lo que hace ArrayList por dentro)
@SuppressWarnings("unchecked")
private T[] items = (T[]) new Object[10];

List<Libro> libros = new ArrayList<>();
List<String> textos = new ArrayList<>();

System.out.println(libros.getClass());                       // class java.util.ArrayList
System.out.println(libros.getClass() == textos.getClass());  // true

public class ComparadorLibros implements Comparator<Libro> {
    @Override
    public int compare(Libro a, Libro b) {
        return a.getTitulo().compareTo(b.getTitulo());
    }
}

// generado por el compilador, marcado como sintetico y puente
public int compare(Object a, Object b) {
    return compare((Libro) a, (Libro) b);   // delega, con el cast
}

List crudo = new ArrayList();       // tipo crudo
crudo.add("cualquier cosa");
crudo.add(42);

Note: Ejemplo.java uses unchecked or unsafe operations.
Note: Recompile with -Xlint:unchecked for details.

public static void envenenar(List crudo) {   // tipo crudo
    crudo.add("no soy un Libro");
}

public static void main(String[] args) {
    List<Libro> catalogo = new ArrayList<>();
    envenenar(catalogo);                     // compila, solo con aviso

    for (Libro l : catalogo) {               // ClassCastException aqui
        System.out.println(l.getTitulo());
    }
}

javac -Xlint:unchecked -Xlint:rawtypes *.java

@SuppressWarnings("unchecked")   // sobre toda la clase: silencia bugs futuros
public class Repositorio<T> { ... }

public <T> T[] copiarEn(T[] destino) {
    if (destino.length < tamano) {
        // SEGURO: Arrays.copyOf con el tipo real del array de destino
        // devuelve un array del mismo tipo que 'destino', que es T[].
        @SuppressWarnings("unchecked")
        T[] nuevo = (T[]) Arrays.copyOf(items, tamano, destino.getClass());
        return nuevo;
    }
    System.arraycopy(items, 0, destino, 0, tamano);
    return destino;
}

package com.nexussoftware.bibliotech.servicio;

import java.lang.reflect.InvocationTargetException;

/**
 * Fabrica generica que SI puede crear instancias de T,
 * porque recibe el Class<T> como token de tipo.
 */
public class FabricaEntidades<T> {

    private final Class<T> tipo;

    public FabricaEntidades(Class<T> tipo) {
        this.tipo = tipo;
    }

    /** Crea una instancia usando el constructor sin argumentos. */
    public T crear() {
        try {
            return tipo.getDeclaredConstructor().newInstance();
        } catch (NoSuchMethodException | InstantiationException
                 | IllegalAccessException | InvocationTargetException e) {
            throw new IllegalStateException(
                    "No se pudo instanciar " + tipo.getSimpleName(), e);
        }
    }

    /**
     * Convierte con seguridad: cast comprobado en EJECUCION.
     * Si el objeto no es del tipo esperado lanza ClassCastException
     * aqui mismo, no tres capas mas abajo.
     */
    public T convertir(Object candidato) {
        return tipo.cast(candidato);
    }

    public String nombreTipo() {
        return tipo.getSimpleName();
    }
}

FabricaEntidades<Libro> fabrica = new FabricaEntidades<>(Libro.class);
Libro nuevo = fabrica.crear();
System.out.println(fabrica.nombreTipo());   // Libro

public class ContextoTipado {

    private final Map<Class<?>, Object> valores = new HashMap<>();

    public <T> void poner(Class<T> tipo, T valor) {
        valores.put(Objects.requireNonNull(tipo), valor);
    }

    public <T> T obtener(Class<T> tipo) {
        return tipo.cast(valores.get(tipo));   // cast seguro
    }
}

ContextoTipado ctx = new ContextoTipado();
ctx.poner(Empleado.class, new Empleado("Marta Ruiz"));
ctx.poner(String.class, "sesión-4711");

Empleado quien = ctx.obtener(Empleado.class);   // sin cast, sin aviso

public <E extends Exception> void ejecutar(Runnable tarea, Class<E> tipo) {
    try {
        tarea.run();
    } catch (E e) {        // ERROR: cannot use the type variable E in a catch clause
        // ...
    }
}

public <E extends Exception> void ejecutar(Runnable tarea, Class<E> tipo) throws E {
    try {
        tarea.run();
    } catch (Exception e) {
        if (tipo.isInstance(e)) {
            throw tipo.cast(e);     // relanzamos ya tipado
        }
        throw new BiblioTechException("Fallo inesperado en la tarea", e);
    }
}

// ERROR: a generic class may not extend java.lang.Throwable
public class ErrorTipado<T> extends BiblioTechException { }

/** Ejecuta la tarea propagando su excepcion tipada. */
public static <T, E extends Exception> T intentar(SupplierConError<T, E> tarea) throws E {
    return tarea.obtener();
}

@FunctionalInterface
public interface SupplierConError<T, E extends Exception> {
    T obtener() throws E;
}

package com.nexussoftware.bibliotech.servicio;

import com.nexussoftware.bibliotech.dominio.Identificable;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Predicate;

/**
 * Repositorio generico y seguro entre hilos para cualquier entidad
 * que sepa dar su identificador.
 *
 * El limite <T extends Identificable> permite llamar a getId()
 * dentro de la clase sin ningun cast.
 */
public class Repositorio<T extends Identificable> {

    private final Map<String, T> porId = new ConcurrentHashMap<>();
    private final String nombre;

    public Repositorio(String nombre) {
        this.nombre = Objects.requireNonNull(nombre, "nombre");
    }

    /** Guarda o reemplaza. Devuelve el valor anterior, si lo habia. */
    public Optional<T> guardar(T entidad) {
        Objects.requireNonNull(entidad, "entidad");
        return Optional.ofNullable(porId.put(entidad.getId(), entidad));
    }

    /** Guarda solo si no existia. true si se insertó. */
    public boolean guardarSiAusente(T entidad) {
        return porId.putIfAbsent(entidad.getId(), entidad) == null;
    }

    public Optional<T> buscarPorId(String id) {
        return Optional.ofNullable(porId.get(id));
    }

    public Optional<T> eliminar(String id) {
        return Optional.ofNullable(porId.remove(id));
    }

    public boolean contiene(String id) {
        return porId.containsKey(id);
    }

    public int tamano() {
        return porId.size();
    }

    /** Vista inmodificable: nadie puede alterar el repositorio por la puerta de atras. */
    public List<T> listarTodos() {
        return List.copyOf(porId.values());
    }

    /**
     * Filtra con un predicado.
     * Predicate<? super T> por PECS: el predicado CONSUME elementos,
     * asi que un Predicate<Identificable> tambien vale.
     */
    public List<T> buscar(Predicate<? super T> criterio) {
        List<T> resultado = new ArrayList<>();
        for (T entidad : porId.values()) {
            if (criterio.test(entidad)) {
                resultado.add(entidad);
            }
        }
        return resultado;
    }

    /**
     * Ordena una copia.
     * Comparator<? super T> por PECS: un Comparator<Identificable> vale
     * para ordenar cualquier subtipo.
     */
    public List<T> listarOrdenado(Comparator<? super T> orden) {
        List<T> copia = new ArrayList<>(porId.values());
        copia.sort(orden);
        return copia;
    }

    /**
     * Vuelca todas las entidades en el destino.
     * ? super T por PECS: el destino CONSUME.
     */
    public void volcarEn(Collection<? super T> destino) {
        destino.addAll(porId.values());
    }

    @Override
    public String toString() {
        return "Repositorio[" + nombre + ", " + porId.size() + " entidades]";
    }
}

public abstract class Material implements Identificable {

    private final String isbn;
    private final String titulo;
    // ... resto del modulo 3

    @Override
    public String getId() {
        return isbn;
    }
}

public class Prestamo implements Identificable {

    private final String referencia;   // p. ej. "PR-2026-0041"

    @Override
    public String getId() {
        return referencia;
    }
}

package com.nexussoftware.bibliotech;

import com.nexussoftware.bibliotech.dominio.*;
import com.nexussoftware.bibliotech.servicio.Repositorio;

import java.util.Comparator;
import java.util.List;

public class BiblioTechApp {

    public static void main(String[] args) {

        Repositorio<Material> catalogo = new Repositorio<>("catálogo");
        Repositorio<Prestamo> prestamos = new Repositorio<>("préstamos");

        catalogo.guardar(new Libro("Java Efectivo", "978-0000000001"));
        catalogo.guardar(new Libro("Patrones de Diseño", "978-0000000002"));
        catalogo.guardar(new Libro("Refactorización", "978-0000000003"));

        prestamos.guardar(new Prestamo("PR-2026-0041", "978-0000000001", "Marta Ruiz"));
        prestamos.guardar(new Prestamo("PR-2026-0042", "978-0000000003", "Diego Alonso"));

        // Ni un solo cast en todo lo que sigue.
        catalogo.buscarPorId("978-0000000001")
                .ifPresent(m -> System.out.println("Encontrado: " + m.getTitulo()));

        List<Material> ordenado =
                catalogo.listarOrdenado(Comparator.comparing(Material::getTitulo));
        ordenado.forEach(m -> System.out.println("  " + m.getTitulo()));

        List<Prestamo> deMarta = prestamos.buscar(p -> p.getEmpleado().equals("Marta Ruiz"));
        System.out.println("Préstamos de Marta: " + deMarta.size());

        System.out.println(catalogo);
        System.out.println(prestamos);
    }
}

Encontrado: Java Efectivo
  Java Efectivo
  Patrones de Diseño
  Refactorización
Préstamos de Marta: 1
Repositorio[catálogo, 3 entidades]
Repositorio[préstamos, 2 entidades]

package com.nexussoftware.bibliotech.servicio;

import java.util.NoSuchElementException;
import java.util.Objects;
import java.util.function.Function;

/**
 * Resultado de una operacion que puede fallar de forma esperable.
 * O contiene un valor de tipo T, o contiene un mensaje de error.
 * Nunca las dos cosas, nunca ninguna.
 *
 * Constructor privado + fabricas estaticas: es imposible construir
 * un Resultado incoherente.
 */
public final class Resultado<T> {

    private final T valor;
    private final String error;

    private Resultado(T valor, String error) {
        this.valor = valor;
        this.error = error;
    }

    /**
     * Metodo generico estatico: declara su propio <U>, porque un
     * metodo static NO puede usar el T de la clase (apartado 7).
     */
    public static <U> Resultado<U> exito(U valor) {
        return new Resultado<>(Objects.requireNonNull(valor, "valor"), null);
    }

    public static <U> Resultado<U> fallo(String error) {
        return new Resultado<>(null, Objects.requireNonNull(error, "error"));
    }

    public boolean esExito() { return error == null; }
    public boolean esFallo() { return error != null; }

    public T valor() {
        if (esFallo()) {
            throw new NoSuchElementException("El resultado es un fallo: " + error);
        }
        return valor;
    }

    public String error() {
        if (esExito()) {
            throw new NoSuchElementException("El resultado es un éxito");
        }
        return error;
    }

    public T oPorDefecto(T alternativa) {
        return esExito() ? valor : alternativa;
    }

    /**
     * Transforma el valor si hay exito; propaga el error si no.
     * Function<? super T, ? extends R> por PECS:
     *   la funcion CONSUME T  -> ? super T
     *   la funcion PRODUCE R  -> ? extends R
     */
    public <R> Resultado<R> map(Function<? super T, ? extends R> transformacion) {
        if (esFallo()) {
            return Resultado.fallo(error);      // el error viaja intacto
        }
        return Resultado.exito(transformacion.apply(valor));
    }

    /** Encadena operaciones que a su vez pueden fallar, sin anidar Resultado<Resultado<R>>. */
    public <R> Resultado<R> flatMap(Function<? super T, Resultado<R>> siguiente) {
        return esFallo() ? Resultado.fallo(error) : siguiente.apply(valor);
    }

    @Override
    public String toString() {
        return esExito() ? "Éxito[" + valor + "]" : "Fallo[" + error + "]";
    }
}

package com.nexussoftware.bibliotech.servicio;

import com.nexussoftware.bibliotech.dominio.*;

public class GestorPrestamos {

    private final Repositorio<Material> catalogo;
    private final Repositorio<Prestamo> prestamos;

    public GestorPrestamos(Repositorio<Material> catalogo, Repositorio<Prestamo> prestamos) {
        this.catalogo = catalogo;
        this.prestamos = prestamos;
    }

    /** El tipo de retorno DICE que esto puede fallar, y con que valor sale bien. */
    public Resultado<Prestamo> prestar(String isbn, String empleado) {

        Material material = catalogo.buscarPorId(isbn).orElse(null);
        if (material == null) {
            return Resultado.fallo("No existe ningún material con ISBN " + isbn);
        }
        if (material.estaPrestado()) {
            return Resultado.fallo("El material '" + material.getTitulo() + "' ya está prestado");
        }

        material.marcarPrestado(empleado);
        Prestamo prestamo = new Prestamo(siguienteReferencia(), isbn, empleado);
        prestamos.guardar(prestamo);
        return Resultado.exito(prestamo);
    }

    private String siguienteReferencia() {
        return String.format("PR-2026-%04d", prestamos.tamano() + 1);
    }
}

Resultado<Prestamo> resultado = gestor.prestar("978-0000000001", "Nuria Vidal");

if (resultado.esExito()) {
    System.out.println("Préstamo registrado: " + resultado.valor().getId());
} else {
    System.out.println("No se pudo prestar: " + resultado.error());
}

// Encadenamiento sin comprobaciones intermedias
String recibo = gestor.prestar("978-0000000002", "Diego Alonso")
        .map(Prestamo::getId)
        .map(id -> "Recibo nº " + id)
        .oPorDefecto("Sin recibo: el préstamo no se pudo registrar");

System.out.println(recibo);

Préstamo registrado: PR-2026-0043
Recibo nº PR-2026-0044

package com.nexussoftware.bibliotech.servicio;

import java.util.*;
import java.util.function.Function;

/**
 * Cache LRU generica con capacidad maxima.
 *
 * K y V son independientes: se puede tener una Cache<String, Ficha>
 * o una Cache<Integer, List<Prestamo>> con la misma clase.
 */
public class Cache<K, V> {

    private final int capacidad;
    private final LinkedHashMap<K, V> mapa;

    private long aciertos = 0;
    private long fallos = 0;

    public Cache(int capacidad) {
        if (capacidad <= 0) {
            throw new IllegalArgumentException("La capacidad debe ser positiva: " + capacidad);
        }
        this.capacidad = capacidad;

        // Tercer argumento true = orden de ACCESO (no de insercion): eso es el LRU.
        // 0.75f es el factor de carga habitual (retoma 05-05).
        this.mapa = new LinkedHashMap<>(capacidad, 0.75f, true) {
            @Override
            protected boolean removeEldestEntry(Map.Entry<K, V> masAntigua) {
                // Cuando devuelve true, LinkedHashMap elimina la entrada mas antigua.
                return size() > Cache.this.capacidad;
            }
        };
    }

    /** Devuelve Optional en vez de null: la ausencia es explicita (ver 10-04). */
    public Optional<V> obtener(K clave) {
        V valor = mapa.get(clave);        // get() reordena por ser orden de acceso
        if (valor != null) {
            aciertos++;
        } else {
            fallos++;
        }
        return Optional.ofNullable(valor);
    }

    public void poner(K clave, V valor) {
        Objects.requireNonNull(clave, "clave");
        Objects.requireNonNull(valor, "valor");
        mapa.put(clave, valor);
    }

    /**
     * PECS aplicado: la funcion CONSUME la clave (? super K)
     * y PRODUCE el valor (? extends V).
     * Asi acepta una Function<Object, Ficha> para una Cache<String, Ficha>.
     */
    public V obtenerOCalcular(K clave, Function<? super K, ? extends V> calculo) {
        V existente = mapa.get(clave);
        if (existente != null) {
            aciertos++;
            return existente;
        }
        fallos++;
        V calculado = calculo.apply(clave);
        mapa.put(clave, calculado);
        return calculado;
    }

    public int tamano() {
        return mapa.size();
    }

    /** De la menos usada recientemente a la mas reciente. */
    public List<K> clavesPorAntiguedad() {
        return new ArrayList<>(mapa.keySet());
    }

    public double tasaAciertos() {
        long total = aciertos + fallos;
        return total == 0 ? 0.0 : (double) aciertos / total;
    }

    @Override
    public String toString() {
        return String.format("Cache[%d/%d entradas, %d aciertos, %d fallos, %.0f%% acierto]",
                mapa.size(), capacidad, aciertos, fallos, tasaAciertos() * 100);
    }
}

public class PruebaCache {

    public static void main(String[] args) {

        Cache<String, Ficha> fichas = new Cache<>(3);

        // El calculo simula una consulta cara (leer del CSV, o pedir por red)
        Function<String, Ficha> consultaCara = isbn -> {
            System.out.println("  [CALCULANDO ficha de " + isbn + "]");
            return new Ficha(isbn, "Título de " + isbn);
        };

        System.out.println("1) " + fichas.obtenerOCalcular("978-0000000001", consultaCara));
        System.out.println("2) " + fichas.obtenerOCalcular("978-0000000002", consultaCara));
        System.out.println("3) " + fichas.obtenerOCalcular("978-0000000001", consultaCara)); // acierto
        System.out.println("4) " + fichas.obtenerOCalcular("978-0000000003", consultaCara));

        System.out.println("Claves antes de desbordar: " + fichas.clavesPorAntiguedad());

        // Esta cuarta clave expulsa a la menos usada recientemente,
        // que es ...0002 (la ...0001 se refresco en el paso 3).
        System.out.println("5) " + fichas.obtenerOCalcular("978-0000000004", consultaCara));

        System.out.println("Claves después:            " + fichas.clavesPorAntiguedad());
        System.out.println(fichas);
    }
}

  [CALCULANDO ficha de 978-0000000001]
1) Ficha[978-0000000001, Título de 978-0000000001]
  [CALCULANDO ficha de 978-0000000002]
2) Ficha[978-0000000002, Título de 978-0000000002]
3) Ficha[978-0000000001, Título de 978-0000000001]
  [CALCULANDO ficha de 978-0000000003]
4) Ficha[978-0000000003, Título de 978-0000000003]
Claves antes de desbordar: [978-0000000002, 978-0000000001, 978-0000000003]
  [CALCULANDO ficha de 978-0000000004]
5) Ficha[978-0000000004, Título de 978-0000000004]
Claves después:            [978-0000000001, 978-0000000003, 978-0000000004]
Cache[3/3 entradas, 1 aciertos, 4 fallos, 20% acierto]

package com.nexussoftware.bibliotech.servicio;

import java.util.*;
import java.util.function.Predicate;

public final class Agregador {

    private Agregador() { }   // clase de utilidad: no se instancia

    /**
     * PRODUCE numeros que leemos -> ? extends Number.
     * Asi acepta List<Integer>, List<Double>, List<Long>...
     * Con Collection<Number> NO aceptaria un List<Integer> (invariancia).
     */
    public static double sumar(Collection<? extends Number> numeros) {
        double total = 0;
        for (Number n : numeros) {
            total += n.doubleValue();
        }
        return total;
    }

    /**
     * origen  PRODUCE  -> ? extends T
     * destino CONSUME  -> ? super T
     * criterio CONSUME -> Predicate<? super T>
     */
    public static <T> int copiarFiltrando(Collection<? extends T> origen,
                                          Collection<? super T> destino,
                                          Predicate<? super T> criterio) {
        int copiados = 0;
        for (T elemento : origen) {
            if (criterio.test(elemento)) {
                destino.add(elemento);
                copiados++;
            }
        }
        return copiados;
    }

    /**
     * elementos PRODUCE -> ? extends T
     * orden     CONSUME -> Comparator<? super T>
     * El retorno NO lleva comodin: Optional<T> limpio.
     */
    public static <T> Optional<T> maximoSegun(Collection<? extends T> elementos,
                                              Comparator<? super T> orden) {
        Iterator<? extends T> it = elementos.iterator();
        if (!it.hasNext()) {
            return Optional.empty();
        }
        T mayor = it.next();
        while (it.hasNext()) {
            T candidato = it.next();
            if (orden.compare(candidato, mayor) > 0) {
                mayor = candidato;
            }
        }
        return Optional.of(mayor);
    }
}

public class PruebaAgregador {

    public static void main(String[] args) {

        // 1) sumar acepta cualquier coleccion de subtipos de Number
        List<Integer> paginas = List.of(412, 395, 448);
        List<Double>  multas  = List.of(1.50, 0.75, 3.20);

        System.out.printf("Páginas totales: %.0f%n", Agregador.sumar(paginas));
        System.out.printf("Multas totales:  %.2f €%n", Agregador.sumar(multas));

        // 2) origen List<Libro>, destino List<Material>: dos tipos DISTINTOS
        List<Libro> libros = new ArrayList<>(List.of(
                new Libro("Java Efectivo",       "978-0000000001", 412, true),
                new Libro("Patrones de Diseño",  "978-0000000002", 395, false),
                new Libro("Refactorización",     "978-0000000003", 448, true)));

        List<Material> prestados = new ArrayList<>();

        int copiados = Agregador.copiarFiltrando(libros, prestados, Libro::estaPrestado);
        System.out.println("Copiados a la lista de materiales: " + copiados);
        prestados.forEach(m -> System.out.println("  " + m.getTitulo()));

        // 3) Comparator<Material> ordenando una List<Libro>: gracias al ? super T
        Comparator<Material> porTitulo = Comparator.comparing(Material::getTitulo);

        Agregador.maximoSegun(libros, porTitulo)
                 .ifPresent(l -> System.out.println("Último alfabéticamente: " + l.getTitulo()));

        // Y el maximo devuelve Libro, no Material: el tipo se conserva
        Optional<Libro> ultimo = Agregador.maximoSegun(libros, porTitulo);
        System.out.println("El tipo estático es Libro: " + ultimo.map(Libro::getIsbn).orElse("-"));
    }
}

Páginas totales: 1255
Multas totales:  5,45 €
Copiados a la lista de materiales: 2
  Java Efectivo
  Refactorización
Último alfabéticamente: Refactorización
El tipo estático es Libro: 978-0000000003

package com.nexussoftware.bibliotech.servicio;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.function.Predicate;

/**
 * Validador generico y encadenable.
 * Acumula reglas y devuelve un Resultado<T> con TODOS los fallos,
 * no solo el primero: quien rellena un formulario agradece verlos juntos.
 */
public final class ValidadorEncadenable<T> {

    /** Par regla-mensaje. Un record generico (04-07 + este apartado 3). */
    private record Regla<T>(Predicate<? super T> condicion, String mensaje) { }

    private final String nombreTipo;
    private final List<Regla<T>> reglas = new ArrayList<>();

    private ValidadorEncadenable(String nombreTipo) {
        this.nombreTipo = nombreTipo;
    }

    /**
     * Token de tipo (apartado 19): el Class<T> aporta el nombre legible
     * y ademas fija T sin necesidad de escribirlo.
     */
    public static <T> ValidadorEncadenable<T> de(Class<T> tipo) {
        return new ValidadorEncadenable<>(tipo.getSimpleName());
    }

    /**
     * Devuelve this para encadenar.
     * Predicate<? super T> por PECS: la regla CONSUME el objeto,
     * asi que un Predicate<Object> o un Predicate<Material> tambien valen.
     */
    public ValidadorEncadenable<T> conRegla(Predicate<? super T> condicion, String mensaje) {
        reglas.add(new Regla<>(Objects.requireNonNull(condicion, "condición"),
                               Objects.requireNonNull(mensaje, "mensaje")));
        return this;
    }

    public Resultado<T> validar(T objeto) {
        if (objeto == null) {
            return Resultado.fallo("El " + nombreTipo + " es nulo");
        }

        List<String> fallos = new ArrayList<>();
        for (Regla<T> regla : reglas) {
            if (!regla.condicion().test(objeto)) {
                fallos.add(regla.mensaje());
            }
        }

        if (fallos.isEmpty()) {
            return Resultado.exito(objeto);
        }
        return Resultado.fallo(nombreTipo + " no válido: " + String.join("; ", fallos));
    }

    public int numeroDeReglas() {
        return reglas.size();
    }
}

public class PruebaValidador {

    public static void main(String[] args) {

        ValidadorEncadenable<Libro> validador = ValidadorEncadenable.de(Libro.class)
                .conRegla(l -> l.getIsbn() != null,                    "el ISBN es obligatorio")
                .conRegla(l -> l.getIsbn() != null
                            && l.getIsbn().length() == 17,             "el ISBN debe tener 17 caracteres")
                .conRegla(l -> l.getTitulo() != null
                            && !l.getTitulo().isBlank(),               "el título no puede estar vacío")
                .conRegla(l -> l.getTitulo() == null
                            || l.getTitulo().length() < 200,           "el título excede los 200 caracteres");

        System.out.println("Reglas configuradas: " + validador.numeroDeReglas());

        List<Libro> candidatos = List.of(
                new Libro("Java Efectivo",      "978-0000000001"),
                new Libro("Patrones de Diseño", "978-1"),
                new Libro("",                   "978-0000000003"));

        for (Libro candidato : candidatos) {
            Resultado<Libro> resultado = validador.validar(candidato);

            // Encadenamiento con map: solo se ejecuta si hubo exito
            String linea = resultado
                    .map(Libro::getTitulo)
                    .map(t -> "ACEPTADO: " + t)
                    .oPorDefecto("RECHAZADO: " + (resultado.esFallo() ? resultado.error() : ""));

            System.out.println(linea);
        }

        // El validador es reutilizable con cualquier Predicate<Material>
        Predicate<Material> tieneTitulo = m -> m.getTitulo() != null;
        ValidadorEncadenable<Libro> otro = ValidadorEncadenable.de(Libro.class)
                .conRegla(tieneTitulo, "necesita título");   // Predicate<Material> en un validador de Libro
        System.out.println(otro.validar(new Libro("Refactorización", "978-0000000003")));
    }
}

Reglas configuradas: 4
ACEPTADO: Java Efectivo
RECHAZADO: Libro no válido: el ISBN debe tener 17 caracteres
RECHAZADO: Libro no válido: el título no puede estar vacío
Éxito[Libro[Refactorización, 978-0000000003]]