javac --release 21 --enable-preview MiClase.java
java --enable-preview MiClase

java --list-modules

[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
[email protected]
...

src/
  module-info.java
  com/nexussoftware/bibliotech/
      BiblioTechApp.java
      dominio/
      servicio/
      persistencia/
      red/
      interno/

/**
 * Modulo principal de BiblioTech.
 */
module com.nexussoftware.bibliotech {

    // --- QUE NECESITO ---
    requires java.logging;              // java.util.logging (06-07)
    requires java.net.http;             // HttpClient (09-06)
    requires java.sql;                  // JDBC, para el modulo 11

    // transitive: quien me requiera a mi obtiene tambien esto
    requires transitive com.nexussoftware.comun;

    // static: necesario para compilar, opcional en ejecucion
    requires static com.nexussoftware.herramientas;

    // --- QUE OFREZCO ---
    exports com.nexussoftware.bibliotech.dominio;
    exports com.nexussoftware.bibliotech.servicio;

    // Exportacion cualificada: SOLO a estos modulos
    exports com.nexussoftware.bibliotech.persistencia
            to com.nexussoftware.bibliotech.pruebas;

    // com.nexussoftware.bibliotech.interno NO se exporta:
    // es inaccesible desde fuera aunque sus clases sean public

    // --- REFLEXION ---
    // opens permite reflexion PROFUNDA (setAccessible sobre privados)
    opens com.nexussoftware.bibliotech.dominio;

    // Apertura cualificada
    opens com.nexussoftware.bibliotech.persistencia to com.fasterxml.jackson.databind;

    // --- SERVICIOS (ServiceLoader) ---
    uses com.nexussoftware.bibliotech.servicio.PoliticaMultas;
    provides com.nexussoftware.bibliotech.servicio.PoliticaMultas
            with com.nexussoftware.bibliotech.interno.PoliticaEstandar;
}

Field valor = String.class.getDeclaredField("value");
valor.setAccessible(true);
byte[] bytes = (byte[]) valor.get("Java Efectivo");

Exception in thread "main" java.lang.reflect.InaccessibleObjectException:
    Unable to make field private final byte[] java.lang.String.value accessible:
    module java.base does not "opens java.lang" to unnamed module @0x1b6d3586

# Abrir un paquete concreto a todo el codigo sin modulo
java --add-opens java.base/java.lang=ALL-UNNAMED -cp app.jar com.ejemplo.App

# Exportar (uso normal, no reflexion profunda)
java --add-exports jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED ...

# Varias a la vez
java --add-opens java.base/java.lang=ALL-UNNAMED \
     --add-opens java.base/java.util=ALL-UNNAMED \
     -jar app.jar

module com.nexussoftware.bibliotech {
    requires java.logging;

    exports com.nexussoftware.bibliotech.dominio;

    // Nuestro ExportadorAnotado de 10-03 hace setAccessible sobre
    // los campos privados de las entidades: necesita opens.
    opens com.nexussoftware.bibliotech.dominio;
}

# CLASSPATH: modo clasico. Todo va al "modulo sin nombre".
javac -cp lib/*.jar -d clases $(find src -name "*.java")
java -cp clases:lib/*.jar com.nexussoftware.bibliotech.BiblioTechApp

# MODULEPATH: modo modular
javac -d clases --module-source-path src $(find src -name "*.java")
java --module-path clases -m com.nexussoftware.bibliotech/com.nexussoftware.bibliotech.BiblioTechApp

# Descubrir que modulos necesita la aplicacion
jdeps --print-module-deps --ignore-missing-deps clases/bibliotech.jar

java.base,java.logging,java.net.http

# Construir el runtime minimo
jlink --add-modules java.base,java.logging,java.net.http \
      --strip-debug \
      --compress=zip-6 \
      --no-header-files \
      --no-man-pages \
      --output runtime-bibliotech

# Y ejecutar con el
./runtime-bibliotech/bin/java -m com.nexussoftware.bibliotech/...BiblioTechApp

du -sh $JAVA_HOME runtime-bibliotech

315M    /usr/lib/jvm/jdk-21
44M     runtime-bibliotech

List<String> empleados = List.of("Marta Ruiz", "Diego Alonso", "Nuria Vidal");
Set<String> isbns = Set.of("978-0000000001", "978-0000000002");
Map<String, Integer> prestamos = Map.of("Marta Ruiz", 4, "Diego Alonso", 2);

Map<String, Integer> muchos = Map.ofEntries(
        Map.entry("Marta Ruiz", 4),
        Map.entry("Diego Alonso", 2),
        Map.entry("Nuria Vidal", 3));

// Copia inmutable de una coleccion existente (Java 10)
List<String> copia = List.copyOf(listaModificable);

Set<String> conjunto = Set.of("a", "b", "c", "d");
System.out.println(conjunto);   // orden distinto en cada ejecucion del programa

public interface ServicioPrestamos {

    Resultado<Prestamo> prestar(String isbn, String empleado);

    default Resultado<Prestamo> prestarValidando(String isbn, String empleado) {
        if (!esIsbnValido(isbn)) {
            return Resultado.fallo("ISBN mal formado: " + isbn);
        }
        if (!esEmpleadoValido(empleado)) {
            return Resultado.fallo("Empleado no válido");
        }
        return prestar(isbn, empleado);
    }

    // PRIVADO: logica compartida entre los default, invisible desde fuera
    private boolean esIsbnValido(String isbn) {
        return isbn != null && isbn.matches("978-\\d{10}");
    }

    private static boolean esEmpleadoValido(String empleado) {
        return empleado != null && !empleado.isBlank();
    }
}

String titulo = "  Java Efectivo  ";

System.out.println(titulo.strip());          // "Java Efectivo"  (Unicode-aware)
System.out.println(titulo.stripLeading());   // "Java Efectivo  "
System.out.println(titulo.stripTrailing());  // "  Java Efectivo"
System.out.println("   ".isBlank());          // true
System.out.println("".isEmpty());             // true
System.out.println("=".repeat(40));           // línea separadora
System.out.println("uno\ndos".lines().count()); // 2  (devuelve Stream<String>)
System.out.println("texto".indent(4));        // sangrado (Java 12)

long lineasNoVacias = textoCompleto.lines()
        .map(String::strip)
        .filter(l -> !l.isBlank())
        .count();

// ANTES
List<String> lineas = Files.readAllLines(ruta, StandardCharsets.UTF_8);
String contenido = String.join("\n", lineas);

// AHORA
String contenido = Files.readString(ruta, StandardCharsets.UTF_8);
Files.writeString(ruta, contenido, StandardCharsets.UTF_8);

List<Libro> catalogo = new ArrayList<>(...);

// ANTES: cada coleccion tenia su forma
Libro primero = catalogo.get(0);
Libro ultimo = catalogo.get(catalogo.size() - 1);
Libro primeroDeque = deque.getFirst();
Libro primeroSet = conjuntoOrdenado.iterator().next();      // ¡así!

// AHORA: SequencedCollection unifica
Libro primero2 = catalogo.getFirst();
Libro ultimo2 = catalogo.getLast();
catalogo.addFirst(nuevo);
catalogo.addLast(otro);
List<Libro> alReves = catalogo.reversed();                  // vista, no copia

// Y funciona igual en LinkedHashSet, TreeSet, Deque, LinkedHashMap
LinkedHashMap<String, Libro> porIsbn = new LinkedHashMap<>();
var primeraEntrada = porIsbn.firstEntry();

String editorial = catalogo.buscarPorIsbn(isbn).getEditorial().getNombre().strip();

Exception in thread "main" java.lang.NullPointerException
    at com.nexussoftware.bibliotech.BiblioTechApp.main(BiblioTechApp.java:42)

Exception in thread "main" java.lang.NullPointerException:
    Cannot invoke "String.strip()" because the return value of
    "com.nexussoftware.bibliotech.dominio.Editorial.getNombre()" is null
    at com.nexussoftware.bibliotech.BiblioTechApp.main(BiblioTechApp.java:42)

var catalogo = new ArrayList<Libro>();                  // ArrayList<Libro>
var titulo = "Java Efectivo";                           // String
var paginas = 412;                                      // int
var fecha = LocalDate.of(2026, 8, 5);                   // LocalDate

// Donde mas brilla: tipos genericos largos
var porEmpleadoYTipo = new HashMap<String, Map<TipoMaterial, List<Prestamo>>>();

// En bucles
for (var entrada : porEmpleadoYTipo.entrySet()) { }
for (var i = 0; i < 10; i++) { }

// En try-with-resources
try (var lineas = Files.lines(ruta, StandardCharsets.UTF_8)) { }

var titulo = "Java Efectivo";
// titulo = 42;         // NO COMPILA: String no admite int

// var campo = "x";                 // campos de clase: NO
// public var metodo() { }          // retorno de método: NO
// void m(var parametro) { }        // parámetros: NO (salvo en lambdas, Java 11)
// var sinValor;                    // sin inicializador: NO
// var nulo = null;                 // no hay nada que inferir: NO
// var array = { 1, 2, 3 };         // inicializador de array: NO

// BIEN: el tipo es evidente por el lado derecho
var catalogo = new ArrayList<Libro>();
var reserva = new Reserva("R-001", "Madrid-A", "Marta Ruiz", inicio, duracion);
var contador = new AtomicInteger(0);

// BIEN: el tipo explícito sería ilegible
var indice = new HashMap<String, Map<TipoMaterial, List<Prestamo>>>();

// MAL: el tipo no se deduce del nombre del método
var resultado = servicio.procesar(datos);      // ¿qué es 'resultado'?
var x = calcular();                             // ¿int? ¿double? ¿BigDecimal?

// MAL: se pierde la abstracción a la interfaz
var lista = new ArrayList<Libro>();             // el tipo es ArrayList
List<Libro> lista2 = new ArrayList<>();         // el tipo es List: mejor API

// PELIGROSO: el diamante vacío infiere Object
var vacia = new ArrayList<>();                  // ArrayList<Object>

lista.forEach((@NoNulo var libro) -> System.out.println(libro.getTitulo()));

// CLASICO: verboso y con trampas
String descripcion;
switch (gravedad) {
    case ALTA:
        descripcion = "Requiere intervención inmediata";
        break;
    case MEDIA:
        descripcion = "Revisar esta semana";
        break;
    case BAJA:
        descripcion = "Anotar y continuar";
        break;
    default:
        throw new IllegalStateException("Gravedad desconocida: " + gravedad);
}

// EXPRESION: devuelve un valor, sin break, sin caida
String descripcion = switch (gravedad) {
    case ALTA  -> "Requiere intervención inmediata";
    case MEDIA -> "Revisar esta semana";
    case BAJA  -> "Anotar y continuar";
};

double multa = switch (gravedad) {
    case ALTA -> {
        double base = dias * 0.50;
        double recargo = dias > 30 ? 10.0 : 0.0;
        yield Math.min(base + recargo, 50.0);      // yield devuelve el valor del bloque
    }
    case MEDIA -> dias * 0.25;
    case BAJA -> 0.0;
};

int diasDePlazo = switch (tipo) {
    case "LIBRO"   -> 21;
    case "REVISTA" -> 7;
    case "DVD"     -> 3;
    default -> throw new IllegalArgumentException("Tipo desconocido: " + tipo);
};

// ANTES: ilegible, con escapes y concatenacion
String json = "{\n"
        + "  \"isbn\": \"978-0000000001\",\n"
        + "  \"titulo\": \"Java Efectivo\",\n"
        + "  \"disponible\": true\n"
        + "}";

// AHORA
String json = """
        {
          "isbn": "978-0000000001",
          "titulo": "Java Efectivo",
          "disponible": true
        }""";

public class Ejemplo {
    public String consulta() {
        String sql = """
                SELECT p.referencia, p.isbn, m.titulo
                  FROM prestamos p
                  JOIN materiales m ON m.isbn = p.isbn
                 WHERE p.fecha_devolucion IS NULL
                 ORDER BY p.fecha_vencimiento
                """;
        return sql;
    }
}

// El cierre a la izquierda del contenido: se conserva mas sangria
String a = """
        línea
  """;                    // el margen comun es 2: "      línea\n"

// El cierre alineado con el contenido: se elimina toda la sangria
String b = """
        línea
        """;              // el margen comun es 8: "línea\n"

// El cierre en la misma linea: sin salto final
String c = """
        línea""";         // "línea"  (sin \n al final)

// \ al final de linea: UNE las lineas (sin salto)
String unaSolaLinea = """
        Este texto está escrito en varias líneas \
        del código fuente pero es una sola \
        línea de resultado.""";

// \s: espacio que NO se elimina como sangria final
String conEspacios = """
        columna1   \s
        columna2   \s""";

public class ConsultasBiblioTech {

    static final String PRESTAMOS_VENCIDOS = """
            SELECT p.referencia,
                   p.isbn,
                   m.titulo,
                   p.empleado,
                   p.fecha_vencimiento,
                   CURRENT_DATE - p.fecha_vencimiento AS dias_retraso
              FROM prestamos p
              JOIN materiales m ON m.isbn = p.isbn
             WHERE p.fecha_devolucion IS NULL
               AND p.fecha_vencimiento < CURRENT_DATE
             ORDER BY dias_retraso DESC
            """;

    static String peticionDeMetadatos(String isbn) {
        return """
                {
                  "jsonrpc": "2.0",
                  "method": "catalogo.buscar",
                  "params": { "isbn": "%s" },
                  "id": 1
                }""".formatted(isbn);           // formatted: como String.format
    }
}

public record Ficha(String isbn, String titulo, boolean disponible) { }

public record Prestamo(String referencia, String isbn, String empleado,
                       LocalDate fechaPrestamo, LocalDate fechaVencimiento) {

    /** Constructor COMPACTO: valida y normaliza antes de asignar. */
    public Prestamo {
        Objects.requireNonNull(referencia, "referencia");
        Objects.requireNonNull(isbn, "isbn");
        if (fechaVencimiento.isBefore(fechaPrestamo)) {
            throw new IllegalArgumentException("Vencimiento anterior al préstamo");
        }
        empleado = empleado.strip();       // se puede NORMALIZAR el parametro
    }

    /** Constructor adicional. */
    public Prestamo(String referencia, String isbn, String empleado, LocalDate desde) {
        this(referencia, isbn, empleado, desde, desde.plusDays(21));
    }

    /** Metodos derivados. */
    public long diasDeRetraso(LocalDate hoy) {
        return Math.max(0, ChronoUnit.DAYS.between(fechaVencimiento, hoy));
    }

    /** "Modificar" un record = crear otro. */
    public Prestamo conVencimiento(LocalDate nuevo) {
        return new Prestamo(referencia, isbn, empleado, fechaPrestamo, nuevo);
    }

    /** Metodos y campos estaticos SI se permiten. */
    public static final Period PLAZO = Period.ofDays(21);

    public static Prestamo nuevo(String ref, String isbn, String empleado, LocalDate desde) {
        return new Prestamo(ref, isbn, empleado, desde, desde.plus(PLAZO));
    }
}

// ANTES: el cast repite lo que el instanceof ya comprobo
if (material instanceof Libro) {
    Libro libro = (Libro) material;
    System.out.println(libro.getPaginas());
}

// AHORA: la variable de patron se declara y asigna a la vez
if (material instanceof Libro libro) {
    System.out.println(libro.getPaginas());
}

// Con && : la variable esta disponible a la derecha
if (material instanceof Libro libro && libro.getPaginas() > 400) {
    System.out.println("Libro largo: " + libro.getTitulo());
}

// Con negacion: disponible DESPUES del if (salida temprana)
public String describir(Object objeto) {
    if (!(objeto instanceof Material material)) {
        return "No es un material";
    }
    // 'material' esta en ambito aqui, porque si no lo fuera ya habriamos vuelto
    return material.getTitulo() + " (" + material.getTipo() + ")";
}

// Con || : NO esta disponible, y el compilador lo impide
// if (o instanceof Libro l || l.getPaginas() > 0) { }   // NO COMPILA

@Override
public boolean equals(Object otro) {
    return otro instanceof Material material
            && isbn.equals(material.getIsbn());
}

// En otro proyecto, sin que nadie lo apruebe
public class Videojuego extends Material { }

package com.nexussoftware.bibliotech.dominio;

/**
 * Jerarquia CERRADA: solo existen estos tres materiales.
 * Ninguna otra clase puede extender Material, ni en este
 * proyecto ni en ninguno.
 */
public sealed abstract class Material
        permits Libro, Revista, Dvd {

    private final String isbn;
    private final String titulo;

    protected Material(String isbn, String titulo) {
        this.isbn = isbn;
        this.titulo = titulo;
    }

    public String getIsbn()   { return isbn; }
    public String getTitulo() { return titulo; }

    public abstract TipoMaterial getTipo();
}

/** final: nadie extiende Libro. Es lo mas habitual. */
public final class Libro extends Material {
    private final int paginas;
    private final String autor;
    // ...
}

/** sealed: Revista tiene a su vez una jerarquia cerrada. */
public sealed class Revista extends Material permits RevistaMensual, RevistaTrimestral {
    // ...
}

/** non-sealed: Dvd vuelve a estar abierto a cualquiera. */
public non-sealed class Dvd extends Material {
    // ...
}

// Todo en un fichero: permits implicito
public sealed interface Evento {
    record Prestado(String isbn, String empleado, LocalDate cuando) implements Evento { }
    record Devuelto(String isbn, LocalDate cuando, boolean conRetraso) implements Evento { }
    record Perdido(String isbn, String empleado, double importe) implements Evento { }
}

// SIN default: el compilador comprueba que estan los tres
String etiqueta = switch (material) {
    case Libro l   -> "Libro de " + l.getPaginas() + " páginas";
    case Revista r -> "Revista nº " + r.getNumero();
    case Dvd d     -> "DVD de " + d.getMinutos() + " minutos";
};

error: the switch expression does not cover all possible input values
    String etiqueta = switch (material) {
                      ^

package com.nexussoftware.bibliotech.dominio;

import java.time.LocalDate;

/**
 * Estado de un prestamo modelado como tipo suma.
 * Cada estado lleva EXACTAMENTE los datos que tiene sentido
 * que lleve, en lugar de una clase con campos que a veces son null.
 */
public sealed interface EstadoPrestamo {

    record Activo(LocalDate vencimiento) implements EstadoPrestamo { }

    record Vencido(LocalDate vencimiento, long diasDeRetraso, double multa)
            implements EstadoPrestamo { }

    record Devuelto(LocalDate cuando, boolean puntual) implements EstadoPrestamo { }

    record Perdido(LocalDate declaradoEl, double importeReposicion)
            implements EstadoPrestamo { }
}

// ANTES: cadena de instanceof, con cast en cada rama
public String describir(Object objeto) {
    if (objeto instanceof Libro) {
        Libro l = (Libro) objeto;
        return "Libro: " + l.getTitulo() + " (" + l.getPaginas() + " págs.)";
    } else if (objeto instanceof Revista) {
        Revista r = (Revista) objeto;
        return "Revista: " + r.getTitulo() + " nº " + r.getNumero();
    } else if (objeto instanceof Dvd) {
        Dvd d = (Dvd) objeto;
        return "DVD: " + d.getTitulo() + " (" + d.getMinutos() + " min)";
    } else if (objeto == null) {
        return "(nada)";
    }
    return "Desconocido";
}

// AHORA
public String describir(Object objeto) {
    return switch (objeto) {
        case null      -> "(nada)";
        case Libro l   -> "Libro: " + l.getTitulo() + " (" + l.getPaginas() + " págs.)";
        case Revista r -> "Revista: " + r.getTitulo() + " nº " + r.getNumero();
        case Dvd d     -> "DVD: " + d.getTitulo() + " (" + d.getMinutos() + " min)";
        default        -> "Desconocido: " + objeto.getClass().getSimpleName();
    };
}

public String clasificar(Material material) {
    return switch (material) {
        case Libro l when l.getPaginas() > 500  -> "Libro extenso";
        case Libro l when l.getPaginas() > 200  -> "Libro estándar";
        case Libro l                            -> "Libro breve";
        case Revista r when r.esEspecial()      -> "Número especial";
        case Revista r                          -> "Revista ordinaria";
        case Dvd d                              -> "Material audiovisual";
    };
}

case Libro l                            -> "...";
case Libro l when l.getPaginas() > 500  -> "...";   // ERROR: inalcanzable

public sealed interface Evento {
    record Prestado(String isbn, String empleado, LocalDate cuando) implements Evento { }
    record Devuelto(String isbn, LocalDate cuando, boolean conRetraso) implements Evento { }
    record Perdido(String isbn, String empleado, double importe) implements Evento { }
}

public String registrar(Evento evento) {
    return switch (evento) {

        // Se DESCOMPONE el record: isbn, empleado y cuando salen directamente
        case Evento.Prestado(String isbn, String empleado, LocalDate cuando) ->
                String.format("%s prestó %s el %s", empleado, isbn, cuando);

        // Con guarda sobre un componente descompuesto
        case Evento.Devuelto(String isbn, LocalDate cuando, boolean retraso) when retraso ->
                String.format("%s devuelto el %s CON RETRASO", isbn, cuando);

        case Evento.Devuelto(String isbn, LocalDate cuando, boolean retraso) ->
                String.format("%s devuelto puntualmente el %s", isbn, cuando);

        case Evento.Perdido(String isbn, String empleado, double importe) ->
                String.format("%s declaró perdido %s (reposición: %.2f €)",
                        empleado, isbn, importe);
    };
    // SIN default: la interfaz es sealed y estan los tres casos
}

case Evento.Prestado(var isbn, var empleado, var cuando) ->
        empleado + " prestó " + isbn + " el " + cuando;

public record Punto(int x, int y) { }
public record Linea(Punto inicio, Punto fin) { }

public String describir(Object o) {
    return switch (o) {
        // Descomposicion ANIDADA en dos niveles
        case Linea(Punto(var x1, var y1), Punto(var x2, var y2)) when x1 == x2 ->
                "Línea vertical en x=" + x1;
        case Linea(Punto(var x1, var y1), Punto(var x2, var y2)) when y1 == y2 ->
                "Línea horizontal en y=" + y1;
        case Linea(Punto p1, Punto p2) ->
                "Línea de " + p1 + " a " + p2;
        case Punto(int x, int y) ->
                "Punto (" + x + ", " + y + ")";
        default -> "Otra cosa";
    };
}

if (evento instanceof Evento.Prestado(String isbn, String empleado, LocalDate cuando)) {
    System.out.println(empleado + " -> " + isbn + " (" + cuando + ")");
}

package com.nexussoftware.bibliotech.servicio;

import com.nexussoftware.bibliotech.dominio.*;

/**
 * VERSION ANTIGUA: jerarquia abierta, casts manuales,
 * cadenas de if-else y un default que oculta los casos nuevos.
 */
public class CalculadoraPlazosAntigua {

    public int diasDePlazo(Material material) {
        if (material instanceof Libro) {
            Libro libro = (Libro) material;
            if (libro.getPaginas() > 500) {
                return 30;
            } else if (libro.getPaginas() > 200) {
                return 21;
            } else {
                return 14;
            }
        } else if (material instanceof Revista) {
            Revista revista = (Revista) material;
            if (revista.esEspecial()) {
                return 14;
            }
            return 7;
        } else if (material instanceof Dvd) {
            return 3;
        }
        // Y si alguien anade un tipo nuevo, cae AQUI en silencio
        throw new IllegalArgumentException("Tipo desconocido: " + material.getClass());
    }

    public String etiquetaDeEstante(Material material) {
        String prefijo;
        if (material instanceof Libro) {
            prefijo = "L";
        } else if (material instanceof Revista) {
            prefijo = "R";
        } else if (material instanceof Dvd) {
            prefijo = "D";
        } else {
            prefijo = "X";
        }
        return prefijo + "-" + material.getIsbn().substring(4, 8);
    }

    public double valorDeReposicion(Material material) {
        if (material instanceof Libro) {
            return ((Libro) material).getPaginas() * 0.08;
        } else if (material instanceof Revista) {
            return 12.0;
        } else if (material instanceof Dvd) {
            return ((Dvd) material).getMinutos() * 0.15;
        }
        return 0.0;
    }
}

package com.nexussoftware.bibliotech.dominio;

/** Jerarquia SELLADA: el compilador sabe que solo existen tres materiales. */
public sealed abstract class Material permits Libro, Revista, Dvd {

    private final String isbn;
    private final String titulo;
    private final double valoracion;

    protected Material(String isbn, String titulo, double valoracion) {
        this.isbn = isbn;
        this.titulo = titulo;
        this.valoracion = valoracion;
    }

    public String getIsbn()      { return isbn; }
    public String getTitulo()    { return titulo; }
    public double getValoracion() { return valoracion; }
}

public final class Libro extends Material {
    private final int paginas;
    private final String autor;

    public Libro(String isbn, String titulo, String autor, int paginas, double valoracion) {
        super(isbn, titulo, valoracion);
        this.autor = autor;
        this.paginas = paginas;
    }
    public int getPaginas()  { return paginas; }
    public String getAutor() { return autor; }
}

public final class Revista extends Material {
    private final int numero;
    private final boolean especial;

    public Revista(String isbn, String titulo, int numero, boolean especial, double valoracion) {
        super(isbn, titulo, valoracion);
        this.numero = numero;
        this.especial = especial;
    }
    public int getNumero()     { return numero; }
    public boolean esEspecial() { return especial; }
}

public final class Dvd extends Material {
    private final int minutos;
    private final String director;

    public Dvd(String isbn, String titulo, String director, int minutos, double valoracion) {
        super(isbn, titulo, valoracion);
        this.director = director;
        this.minutos = minutos;
    }
    public int getMinutos()     { return minutos; }
    public String getDirector() { return director; }
}

package com.nexussoftware.bibliotech.servicio;

import com.nexussoftware.bibliotech.dominio.*;

/**
 * VERSION MODERNA: switch exhaustivo sin default,
 * sin casts, con guardas. Si se anade un cuarto material,
 * ESTOS TRES METODOS DEJAN DE COMPILAR y el compilador
 * te lleva a cada uno.
 */
public class CalculadoraPlazos {

    public int diasDePlazo(Material material) {
        return switch (material) {
            case Libro l when l.getPaginas() > 500 -> 30;
            case Libro l when l.getPaginas() > 200 -> 21;
            case Libro l                           -> 14;
            case Revista r when r.esEspecial()     -> 14;
            case Revista r                         -> 7;
            case Dvd d                             -> 3;
        };
    }

    public String etiquetaDeEstante(Material material) {
        String prefijo = switch (material) {
            case Libro l   -> "L";
            case Revista r -> "R";
            case Dvd d     -> "D";
        };
        return prefijo + "-" + material.getIsbn().substring(4, 8);
    }

    public double valorDeReposicion(Material material) {
        return switch (material) {
            case Libro l   -> l.getPaginas() * 0.08;
            case Revista r -> r.esEspecial() ? 25.0 : 12.0;
            case Dvd d     -> d.getMinutos() * 0.15;
        };
    }

    /** Con bloques y yield cuando hay logica. */
    public String fichaCompleta(Material material) {
        return switch (material) {
            case Libro l -> {
                String extension = l.getPaginas() > 400 ? "extenso" : "estándar";
                yield """
                        LIBRO
                          Título:     %s
                          Autor:      %s
                          Páginas:    %d (%s)
                          Plazo:      %d días
                          Reposición: %.2f €"""
                        .formatted(l.getTitulo(), l.getAutor(), l.getPaginas(),
                                   extension, diasDePlazo(l), valorDeReposicion(l));
            }
            case Revista r -> """
                    REVISTA
                      Título:     %s
                      Número:     %d%s
                      Plazo:      %d días"""
                    .formatted(r.getTitulo(), r.getNumero(),
                               r.esEspecial() ? " (ESPECIAL)" : "", diasDePlazo(r));
            case Dvd d -> """
                    DVD
                      Título:     %s
                      Director:   %s
                      Duración:   %d min
                      Plazo:      %d días"""
                    .formatted(d.getTitulo(), d.getDirector(), d.getMinutos(), diasDePlazo(d));
        };
    }
}

package com.nexussoftware.bibliotech.servicio;

import com.nexussoftware.bibliotech.dominio.EstadoPrestamo;

import java.time.format.DateTimeFormatter;
import java.util.Locale;

public class DescriptorDeEstado {

    private static final DateTimeFormatter FECHA =
            DateTimeFormatter.ofPattern("d 'de' MMMM", new Locale("es", "ES"));

    public String describir(EstadoPrestamo estado) {
        return switch (estado) {

            case EstadoPrestamo.Activo(var vencimiento) ->
                    "Activo, vence el " + vencimiento.format(FECHA);

            case EstadoPrestamo.Vencido(var vencimiento, var dias, var multa) when multa == 0 ->
                    "Vencido hace " + dias + " días (todavía en período de cortesía)";

            case EstadoPrestamo.Vencido(var vencimiento, var dias, var multa) ->
                    String.format("VENCIDO hace %d días -- multa acumulada: %.2f €", dias, multa);

            case EstadoPrestamo.Devuelto(var cuando, var puntual) ->
                    "Devuelto el " + cuando.format(FECHA) + (puntual ? " puntualmente" : " con retraso");

            case EstadoPrestamo.Perdido(var declarado, var importe) ->
                    String.format("PERDIDO desde el %s -- reposición: %.2f €",
                            declarado.format(FECHA), importe);
        };
    }

    /** Prioridad de gestion: un switch que devuelve un int. */
    public int prioridad(EstadoPrestamo estado) {
        return switch (estado) {
            case EstadoPrestamo.Perdido p                              -> 100;
            case EstadoPrestamo.Vencido(var v, var dias, var m) when dias > 30 -> 90;
            case EstadoPrestamo.Vencido v                              -> 50;
            case EstadoPrestamo.Activo a                               -> 10;
            case EstadoPrestamo.Devuelto d                             -> 0;
        };
    }
}

List<EstadoPrestamo> estados = List.of(
        new EstadoPrestamo.Activo(LocalDate.of(2026, 8, 26)),
        new EstadoPrestamo.Vencido(LocalDate.of(2026, 8, 3), 2, 0.0),
        new EstadoPrestamo.Vencido(LocalDate.of(2026, 5, 22), 75, 18.25),
        new EstadoPrestamo.Devuelto(LocalDate.of(2026, 8, 1), true),
        new EstadoPrestamo.Perdido(LocalDate.of(2026, 7, 15), 42.50));

DescriptorDeEstado descriptor = new DescriptorDeEstado();

estados.stream()
       .sorted(Comparator.comparingInt(descriptor::prioridad).reversed())
       .forEach(e -> System.out.printf("  [%3d] %s%n",
               descriptor.prioridad(e), descriptor.describir(e)));

  [100] PERDIDO desde el 15 de julio -- reposición: 42,50 €
  [ 90] VENCIDO hace 75 días -- multa acumulada: 18,25 €
  [ 50] Vencido hace 2 días (todavía en período de cortesía)
  [ 10] Activo, vence el 26 de agosto
  [  0] Devuelto el 1 de agosto puntualmente

// Crear uno suelto
Thread virtual = Thread.ofVirtual().name("worker-1").start(() -> {
    System.out.println("Soy un hilo virtual: " + Thread.currentThread());
});
virtual.join();

// Sin arrancar
Thread sinArrancar = Thread.ofVirtual().unstarted(tarea);

// Fabrica de hilos virtuales
ThreadFactory fabrica = Thread.ofVirtual().name("bibliotech-", 0).factory();

// EL MAS IMPORTANTE: executor con un hilo virtual POR TAREA
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    for (int i = 0; i < 10_000; i++) {
        executor.submit(() -> {
            Thread.sleep(Duration.ofSeconds(1));
            return "listo";
        });
    }
}   // close() espera a que terminen todas: el executor es AutoCloseable

package com.nexussoftware.bibliotech;

import java.time.Duration;
import java.util.concurrent.*;
import java.util.stream.IntStream;

public class DemostracionHilosVirtuales {

    private static final int TAREAS = 10_000;

    public static void main(String[] args) throws Exception {
        System.out.println("Tareas: " + TAREAS + ", cada una bloqueada 1 segundo");
        System.out.println("Núcleos: " + Runtime.getRuntime().availableProcessors());
        System.out.println();

        medir("Pool de plataforma (200 hilos)",
              Executors.newFixedThreadPool(200));

        medir("Un hilo VIRTUAL por tarea      ",
              Executors.newVirtualThreadPerTaskExecutor());

        // Y esto NO se puede hacer con hilos de plataforma
        System.out.println();
        System.out.println("--- 1.000.000 de hilos virtuales ---");
        long inicio = System.currentTimeMillis();
        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            IntStream.range(0, 1_000_000).forEach(i ->
                    executor.submit(() -> {
                        Thread.sleep(Duration.ofSeconds(1));
                        return i;
                    }));
        }
        System.out.printf("Un millón de tareas en %d ms%n",
                System.currentTimeMillis() - inicio);
    }

    private static void medir(String etiqueta, ExecutorService executor) throws Exception {
        long inicio = System.currentTimeMillis();
        try (executor) {
            for (int i = 0; i < TAREAS; i++) {
                executor.submit(() -> {
                    Thread.sleep(Duration.ofSeconds(1));   // simula espera de E/S
                    return null;
                });
            }
        }
        System.out.printf("%s -> %6d ms%n", etiqueta, System.currentTimeMillis() - inicio);
    }
}

Tareas: 10000, cada una bloqueada 1 segundo
Núcleos: 8

Pool de plataforma (200 hilos) ->  50238 ms
Un hilo VIRTUAL por tarea       ->   1104 ms

--- 1.000.000 de hilos virtuales ---
Un millón de tareas en 2871 ms

// MAL: contradice el propósito
ExecutorService mal = Executors.newFixedThreadPool(200, Thread.ofVirtual().factory());

// BIEN: uno por tarea
ExecutorService bien = Executors.newVirtualThreadPerTaskExecutor();

Semaphore limite = new Semaphore(50);

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    for (String isbn : isbns) {
        executor.submit(() -> {
            limite.acquire();
            try {
                return clienteMetadatos.consultar(isbn);
            } finally {
                limite.release();
            }
        });
    }
}

package com.nexussoftware.bibliotech.red;

import java.io.IOException;
import java.net.*;
import java.util.concurrent.*;
import java.util.logging.Logger;

/**
 * VERSION DEL MODULO 9: pool acotado.
 *
 * El pool limita a 50 clientes simultaneos. Con 51 conexiones,
 * la 51 espera en la cola; si la cola se llena, se RECHAZA.
 * Y no se puede subir mucho: cada hilo son ~1 MB de pila.
 */
public class ServidorCatalogoConPool {

    private static final Logger LOG = Logger.getLogger(ServidorCatalogoConPool.class.getName());

    private static final int PUERTO = 9090;
    private static final int MAX_CLIENTES = 50;      // <-- el limite
    private static final int COLA = 100;

    private final ExecutorService pool = new ThreadPoolExecutor(
            MAX_CLIENTES, MAX_CLIENTES,
            60L, TimeUnit.SECONDS,
            new ArrayBlockingQueue<>(COLA),
            new ThreadPoolExecutor.CallerRunsPolicy());

    private volatile boolean activo = true;

    public void arrancar() throws IOException {
        try (ServerSocket servidor = new ServerSocket(PUERTO)) {
            servidor.setSoTimeout(1000);
            LOG.info("Servidor en el puerto " + PUERTO + " (máx. " + MAX_CLIENTES + " clientes)");

            while (activo) {
                try {
                    Socket cliente = servidor.accept();
                    pool.submit(() -> atender(cliente));
                } catch (SocketTimeoutException e) {
                    // ciclo de comprobacion de 'activo'
                }
            }
        } finally {
            pool.shutdown();
        }
    }

    private void atender(Socket cliente) { /* protocolo BTCP/1 */ }
}

package com.nexussoftware.bibliotech.red;

import java.io.*;
import java.net.*;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicLong;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * VERSION CON HILOS VIRTUALES.
 *
 * Un hilo virtual por conexion, sin pool y sin limite artificial.
 * El codigo de atender() es SECUENCIAL y BLOQUEANTE, que es como
 * hay que escribirlo, y aun asi escala a decenas de miles de clientes.
 */
public class ServidorCatalogo implements AutoCloseable {

    private static final Logger LOG = Logger.getLogger(ServidorCatalogo.class.getName());

    private static final int PUERTO = 9090;
    private static final Duration INACTIVIDAD = Duration.ofSeconds(30);
    private static final int MAX_LINEA = 4096;

    /**
     * Un hilo VIRTUAL por tarea. Ya no hay tamaño de pool que ajustar,
     * ni cola, ni politica de rechazo.
     */
    private final ExecutorService atendedores = Executors.newVirtualThreadPerTaskExecutor();

    private final AtomicLong conexionesTotales = new AtomicLong();
    private final AtomicLong conexionesActivas = new AtomicLong();

    private volatile boolean activo = true;
    private ServerSocket servidor;

    public void arrancar() throws IOException {
        servidor = new ServerSocket(PUERTO);
        servidor.setSoTimeout(1000);

        LOG.info(() -> "ServidorCatalogo escuchando en el puerto " + PUERTO
                + " (un hilo virtual por conexión, sin límite de pool)");

        // Hilo virtual dedicado a informar del estado
        Thread.ofVirtual().name("monitor").start(this::monitorizar);

        while (activo) {
            try {
                Socket cliente = servidor.accept();

                // Un hilo virtual POR CONEXION. Crearlo cuesta microsegundos.
                atendedores.submit(() -> atender(cliente));

            } catch (SocketTimeoutException e) {
                // ciclo normal
            } catch (IOException e) {
                if (activo) {
                    LOG.log(Level.WARNING, "Error al aceptar conexión", e);
                }
            }
        }
    }

    /**
     * Codigo SECUENCIAL y BLOQUEANTE: exactamente el mismo de 09-03.
     * readLine() bloquea, y no pasa nada: el hilo virtual se desmonta.
     */
    private void atender(Socket cliente) {
        long numero = conexionesTotales.incrementAndGet();
        conexionesActivas.incrementAndGet();

        // Nombrar el hilo hace legibles las trazas y los volcados
        Thread.currentThread().setName("cliente-" + numero);

        try (cliente;
             var entrada = new BufferedReader(new InputStreamReader(
                     cliente.getInputStream(), StandardCharsets.UTF_8));
             var salida = new PrintWriter(new OutputStreamWriter(
                     cliente.getOutputStream(), StandardCharsets.UTF_8), true)) {

            cliente.setSoTimeout((int) INACTIVIDAD.toMillis());

            salida.println("BTCP/1 BIENVENIDO BiblioTech");

            String linea;
            while ((linea = leerLineaAcotada(entrada)) != null) {

                String respuesta = switch (linea.split(" ", 2)[0].toUpperCase()) {
                    case "BUSCAR"  -> buscar(linea);
                    case "PRESTAR" -> prestar(linea);
                    case "ESTADO"  -> "OK ACTIVAS=" + conexionesActivas.get()
                                      + " TOTALES=" + conexionesTotales.get();
                    case "ADIOS"   -> "OK HASTA_LUEGO";
                    default        -> "ERROR COMANDO_DESCONOCIDO";
                };

                salida.println(respuesta);

                if (respuesta.startsWith("OK HASTA_LUEGO")) {
                    break;
                }
            }

        } catch (SocketTimeoutException e) {
            LOG.fine(() -> "Cliente " + numero + " expulsado por inactividad");
        } catch (IOException e) {
            LOG.log(Level.FINE, e, () -> "Error con el cliente " + numero);
        } finally {
            conexionesActivas.decrementAndGet();
        }
    }

    private String leerLineaAcotada(BufferedReader entrada) throws IOException {
        StringBuilder sb = new StringBuilder();
        int c;
        while ((c = entrada.read()) != -1) {
            if (c == '\n') {
                return sb.toString().strip();
            }
            if (sb.length() >= MAX_LINEA) {
                throw new IOException("Línea demasiado larga: posible ataque");
            }
            sb.append((char) c);
        }
        return sb.isEmpty() ? null : sb.toString().strip();
    }

    private void monitorizar() {
        while (activo) {
            try {
                Thread.sleep(Duration.ofSeconds(10));
                LOG.info(() -> String.format("Conexiones: %d activas, %d totales",
                        conexionesActivas.get(), conexionesTotales.get()));
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                return;
            }
        }
    }

    private String buscar(String comando)  { return "OK ..."; }
    private String prestar(String comando) { return "OK ..."; }

    @Override
    public void close() throws IOException {
        activo = false;
        if (servidor != null) {
            servidor.close();
        }
        atendedores.close();       // espera a que terminen los clientes en curso
        LOG.info("Servidor detenido");
    }

    public static void main(String[] args) throws IOException {
        try (var servidor = new ServidorCatalogo()) {
            Runtime.getRuntime().addShutdownHook(new Thread(() -> {
                try { servidor.close(); } catch (IOException ignored) { }
            }));
            servidor.arrancar();
        }
    }
}

// PROBLEMA: bloqueo dentro de synchronized
public class CacheProblematica {

    private final Map<String, Ficha> cache = new HashMap<>();

    public synchronized Ficha obtener(String isbn) {   // synchronized
        return cache.computeIfAbsent(isbn, clave -> {
            return clienteMetadatos.consultar(clave);  // BLOQUEA en red -> PINNING
        });
    }
}

// SOLUCION: ReentrantLock, que SI permite desmontar
public class CacheCorrecta {

    private final Map<String, Ficha> cache = new ConcurrentHashMap<>();
    private final ReentrantLock cerrojo = new ReentrantLock();

    public Ficha obtener(String isbn) {
        Ficha existente = cache.get(isbn);
        if (existente != null) {
            return existente;
        }

        cerrojo.lock();                     // ReentrantLock (08-04): sin pinning
        try {
            return cache.computeIfAbsent(isbn, clienteMetadatos::consultar);
        } finally {
            cerrojo.unlock();
        }
    }
}

java -Djdk.tracePinnedThreads=full -jar bibliotech.jar

Thread[#31,ForkJoinPool-1-worker-1,5,CarrierThreads]
    com.nexussoftware.bibliotech.servicio.CacheProblematica.obtener(CacheProblematica.java:12)
    <== monitors:1

// INUTIL: la tarea no se bloquea nunca
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    for (int i = 0; i < 10_000; i++) {
        executor.submit(() -> calcularHashCostoso(datos));   // puro CPU
    }
}

// Con StructuredTaskScope: el ambito CONTIENE a las subtareas
try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {

    Subtask<Ficha> ficha = scope.fork(() -> clienteMetadatos.consultar(isbn));
    Subtask<byte[]> portada = scope.fork(() -> clientePortadas.descargar(isbn));
    Subtask<List<String>> resenas = scope.fork(() -> clienteResenas.buscar(isbn));

    scope.join();                  // espera a las tres
    scope.throwIfFailed();         // si alguna fallo, lanza y CANCELA las demas

    return new FichaCompleta(ficha.get(), portada.get(), resenas.get());
}   // close() garantiza que ninguna subtarea sigue viva

public class ContextoBiblioTech {

    // Inmutable y con ambito acotado, a diferencia de ThreadLocal
    public static final ScopedValue<String> EMPLEADO = ScopedValue.newInstance();

    public void atenderPeticion(String empleado, Runnable tarea) {
        ScopedValue.where(EMPLEADO, empleado).run(tarea);
        // Fuera de aqui, EMPLEADO no esta ligado
    }

    public void enAlgunSitioProfundo() {
        if (EMPLEADO.isBound()) {
            LOG.info("Operación de " + EMPLEADO.get());
        }
    }
}

jshell

jshell> var catalogo = new java.util.ArrayList<String>()
catalogo ==> []

jshell> catalogo.add("Java Efectivo")
$2 ==> true

jshell> catalogo.stream().map(String::toUpperCase).toList()
$3 ==> [JAVA EFECTIVO]

jshell> java.time.LocalDate.now().plusDays(21)
$4 ==> 2026-08-26

jshell> /exit

java Hola.java

jpackage --name BiblioTech \
         --input dist/ \
         --main-jar bibliotech.jar \
         --main-class com.nexussoftware.bibliotech.BiblioTechApp \
         --runtime-image runtime-bibliotech \
         --type deb \
         --app-version 3.2

jwebserver -p 8000 -d /home/joan/bibliotech/informes

jdeps --jdk-internals bibliotech.jar

# 1. Detectar usos de API interna ANTES de tocar nada
jdeps --jdk-internals --multi-release 21 bibliotech.jar

# 2. Compilar con la version nueva pero destino antiguo
javac --release 11 ...

# 3. Ejecutar con la JVM nueva y el codigo antiguo, viendo los avisos
java --illegal-access=warn -jar bibliotech.jar     # hasta Java 16

# 4. Actualizar dependencias UNA a UNA, no todas de golpe

# 5. Subir el destino de compilacion
javac --release 21 ...

# 6. Modernizar el codigo (opcional y gradual):
#    var, switch de expresion, records, bloques de texto, streams

package com.nexussoftware.bibliotech.dominio;

import java.util.List;

/**
 * Raiz SELLADA del catalogo. Un elemento es, o un material concreto,
 * o una coleccion que agrupa otros elementos.
 */
public sealed interface ElementoCatalogo permits Material, Coleccion {

    String getIsbn();
    String getTitulo();
}

package com.nexussoftware.bibliotech.dominio;

import java.util.List;
import java.util.Objects;

/**
 * Agrupacion de elementos. Puede contener colecciones anidadas:
 * es una estructura recursiva (el patron Composite, formalizado en 12-02).
 */
public record Coleccion(String isbn, String titulo, List<ElementoCatalogo> elementos)
        implements ElementoCatalogo {

    public Coleccion {
        Objects.requireNonNull(isbn, "isbn");
        Objects.requireNonNull(titulo, "titulo");
        elementos = List.copyOf(elementos);      // copia defensiva inmutable
    }

    @Override public String getIsbn()   { return isbn; }
    @Override public String getTitulo() { return titulo; }
}

package com.nexussoftware.bibliotech.dominio;

/**
 * Jerarquia de materiales, CERRADA a cuatro tipos.
 * Cada subclase declara explicitamente si se puede extender.
 */
public sealed abstract class Material
        implements ElementoCatalogo
        permits Libro, Revista, Dvd, AudioLibro {

    private final String isbn;
    private final String titulo;
    private final double valoracion;

    protected Material(String isbn, String titulo, double valoracion) {
        this.isbn = isbn;
        this.titulo = titulo;
        this.valoracion = valoracion;
    }

    @Override public String getIsbn()   { return isbn; }
    @Override public String getTitulo() { return titulo; }
    public double getValoracion()       { return valoracion; }
}

/** final: cerrada del todo. */
public final class Libro extends Material {
    private final String autor;
    private final int paginas;

    public Libro(String isbn, String titulo, String autor, int paginas, double valoracion) {
        super(isbn, titulo, valoracion);
        this.autor = autor;
        this.paginas = paginas;
    }
    public String getAutor() { return autor; }
    public int getPaginas()  { return paginas; }
}

/** sealed: su propia jerarquia cerrada de dos periodicidades. */
public sealed class Revista extends Material
        permits RevistaMensual, RevistaTrimestral {

    private final int numero;

    protected Revista(String isbn, String titulo, int numero, double valoracion) {
        super(isbn, titulo, valoracion);
        this.numero = numero;
    }
    public int getNumero() { return numero; }
}

public final class RevistaMensual extends Revista {
    private final java.time.Month mes;
    public RevistaMensual(String isbn, String titulo, int numero,
                          java.time.Month mes, double valoracion) {
        super(isbn, titulo, numero, valoracion);
        this.mes = mes;
    }
    public java.time.Month getMes() { return mes; }
}

public final class RevistaTrimestral extends Revista {
    private final int trimestre;
    public RevistaTrimestral(String isbn, String titulo, int numero,
                             int trimestre, double valoracion) {
        super(isbn, titulo, numero, valoracion);
        this.trimestre = trimestre;
    }
    public int getTrimestre() { return trimestre; }
}

/** final. */
public final class Dvd extends Material {
    private final String director;
    private final int minutos;
    public Dvd(String isbn, String titulo, String director, int minutos, double valoracion) {
        super(isbn, titulo, valoracion);
        this.director = director;
        this.minutos = minutos;
    }
    public String getDirector() { return director; }
    public int getMinutos()     { return minutos; }
}

/** non-sealed: DELIBERADAMENTE abierta a extension por terceros. */
public non-sealed class AudioLibro extends Material {
    private final String narrador;
    private final int minutos;
    public AudioLibro(String isbn, String titulo, String narrador, int minutos, double valoracion) {
        super(isbn, titulo, valoracion);
        this.narrador = narrador;
        this.minutos = minutos;
    }
    public String getNarrador() { return narrador; }
    public int getMinutos()     { return minutos; }
}

package com.nexussoftware.bibliotech.dominio;

import java.util.List;

/** Tipo suma para el resultado de una busqueda. */
public sealed interface ResultadoBusqueda {

    record Encontrado(Material material) implements ResultadoBusqueda { }

    record NoEncontrado(String consulta, List<String> sugerencias) implements ResultadoBusqueda { }

    record Ambiguo(String consulta, List<Material> candidatos) implements ResultadoBusqueda { }
}

package com.nexussoftware.bibliotech.servicio;

import com.nexussoftware.bibliotech.dominio.*;

/**
 * Todos los switch son EXHAUSTIVOS y sin default.
 * Si se anade un quinto material, ninguno compila.
 */
public class ServicioCatalogo {

    public int diasDePlazo(Material material) {
        return switch (material) {
            case Libro l when l.getPaginas() > 500  -> 30;
            case Libro l when l.getPaginas() > 200  -> 21;
            case Libro l                            -> 14;
            case RevistaMensual r                   -> 7;
            case RevistaTrimestral r                -> 14;
            case Dvd d when d.getMinutos() > 180    -> 5;
            case Dvd d                              -> 3;
            case AudioLibro a                       -> 21;
        };
        // Revista es sealed: el compilador acepta cubrir sus dos subtipos
        // en lugar de Revista, y comprueba que estan los dos.
    }

    public double valorDeReposicion(Material material) {
        return switch (material) {
            case Libro l             -> Math.max(15.0, l.getPaginas() * 0.08);
            case RevistaMensual r    -> 8.0;
            case RevistaTrimestral r -> 14.0;
            case Dvd d               -> Math.max(10.0, d.getMinutos() * 0.15);
            case AudioLibro a        -> Math.max(20.0, a.getMinutos() * 0.10);
        };
    }

    public String etiquetaDeEstante(ElementoCatalogo elemento) {
        String prefijo = switch (elemento) {
            case Libro l             -> "LIB";
            case RevistaMensual r    -> "REM";
            case RevistaTrimestral r -> "RET";
            case Dvd d               -> "DVD";
            case AudioLibro a        -> "AUD";
            case Coleccion c         -> "COL";
        };
        return prefijo + "-" + elemento.getIsbn().substring(4, 8);
    }

    /** Ficha con bloques de texto y formatted (Java 15). */
    public String ficha(ElementoCatalogo elemento) {
        return switch (elemento) {

            case Libro l -> """
                    ┌─ LIBRO ─────────────────────────────
                    │ %s
                    │ Autor:      %s
                    │ Páginas:    %d
                    │ Estante:    %s
                    │ Plazo:      %d días
                    │ Reposición: %.2f €
                    └─────────────────────────────────────"""
                    .formatted(l.getTitulo(), l.getAutor(), l.getPaginas(),
                               etiquetaDeEstante(l), diasDePlazo(l), valorDeReposicion(l));

            case RevistaMensual r -> """
                    ┌─ REVISTA MENSUAL ───────────────────
                    │ %s nº %d (%s)
                    │ Estante:    %s
                    │ Plazo:      %d días
                    └─────────────────────────────────────"""
                    .formatted(r.getTitulo(), r.getNumero(), r.getMes(),
                               etiquetaDeEstante(r), diasDePlazo(r));

            case RevistaTrimestral r -> """
                    ┌─ REVISTA TRIMESTRAL ────────────────
                    │ %s nº %d (T%d)
                    │ Estante:    %s
                    │ Plazo:      %d días
                    └─────────────────────────────────────"""
                    .formatted(r.getTitulo(), r.getNumero(), r.getTrimestre(),
                               etiquetaDeEstante(r), diasDePlazo(r));

            case Dvd d -> """
                    ┌─ DVD ───────────────────────────────
                    │ %s
                    │ Director:   %s
                    │ Duración:   %d min
                    │ Plazo:      %d días
                    └─────────────────────────────────────"""
                    .formatted(d.getTitulo(), d.getDirector(), d.getMinutos(), diasDePlazo(d));

            case AudioLibro a -> """
                    ┌─ AUDIOLIBRO ────────────────────────
                    │ %s
                    │ Narrador:   %s
                    │ Duración:   %d min
                    │ Plazo:      %d días
                    └─────────────────────────────────────"""
                    .formatted(a.getTitulo(), a.getNarrador(), a.getMinutos(), diasDePlazo(a));

            case Coleccion(var isbn, var titulo, var elementos) -> """
                    ┌─ COLECCIÓN ─────────────────────────
                    │ %s
                    │ Elementos:  %d directos, %d en total
                    │ Estante:    %s
                    └─────────────────────────────────────"""
                    .formatted(titulo, elementos.size(),
                               contarMateriales(elemento), etiquetaDeEstante(elemento));
        };
    }

    /**
     * RECURSIVO con patron de registro: la coleccion se descompone
     * y se desciende por sus elementos.
     */
    public int contarMateriales(ElementoCatalogo elemento) {
        return switch (elemento) {
            case Material m -> 1;
            case Coleccion(var isbn, var titulo, var elementos) ->
                    elementos.stream()
                             .mapToInt(this::contarMateriales)     // recursion
                             .sum();
        };
    }

    /** Profundidad maxima de anidamiento. */
    public int profundidad(ElementoCatalogo elemento) {
        return switch (elemento) {
            case Material m -> 0;
            case Coleccion(var isbn, var titulo, var elementos) ->
                    1 + elementos.stream()
                                 .mapToInt(this::profundidad)
                                 .max().orElse(0);
        };
    }

    /** El resultado de busqueda, tambien con switch exhaustivo. */
    public String describirBusqueda(ResultadoBusqueda resultado) {
        return switch (resultado) {

            case ResultadoBusqueda.Encontrado(Material m) ->
                    "Encontrado: " + m.getTitulo();

            case ResultadoBusqueda.NoEncontrado(var consulta, var sugerencias)
                    when sugerencias.isEmpty() ->
                    "No hay resultados para \"" + consulta + "\"";

            case ResultadoBusqueda.NoEncontrado(var consulta, var sugerencias) ->
                    "No hay resultados para \"" + consulta + "\". ¿Quizás: "
                    + String.join(", ", sugerencias) + "?";

            case ResultadoBusqueda.Ambiguo(var consulta, var candidatos) ->
                    candidatos.size() + " coincidencias para \"" + consulta + "\": "
                    + candidatos.stream().map(Material::getTitulo)
                                .collect(java.util.stream.Collectors.joining(", "));
        };
    }
}

package com.nexussoftware.bibliotech;

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

import java.time.Month;
import java.util.List;

public class PruebaCatalogoSellado {

    public static void main(String[] args) {

        ServicioCatalogo servicio = new ServicioCatalogo();

        Libro efectivo = new Libro("978-0000000001", "Java Efectivo", "Joshua Bloch", 412, 4.85);
        Libro patrones = new Libro("978-0000000002", "Patrones de Diseño", "GoF", 395, 4.60);
        Libro refactor = new Libro("978-0000000003", "Refactorización", "M. Fowler", 448, 4.72);
        RevistaMensual javaMag = new RevistaMensual("978-0000000010", "Java Magazine",
                                                    142, Month.AUGUST, 3.90);
        Dvd cursoSpring = new Dvd("978-0000000020", "Curso de Spring", "N. Vidal", 240, 4.10);
        AudioLibro audio = new AudioLibro("978-0000000030", "Clean Code (audio)",
                                          "D. Alonso", 480, 4.30);

        // Coleccion ANIDADA
        Coleccion esenciales = new Coleccion("978-1000000001", "Esenciales de Java",
                List.of(efectivo, patrones, refactor));

        Coleccion multimedia = new Coleccion("978-1000000002", "Formación multimedia",
                List.of(cursoSpring, audio));

        Coleccion completa = new Coleccion("978-1000000000", "Biblioteca técnica Nexus",
                List.of(esenciales, multimedia, javaMag));

        System.out.println(servicio.ficha(efectivo));
        System.out.println(servicio.ficha(javaMag));
        System.out.println(servicio.ficha(audio));
        System.out.println(servicio.ficha(completa));

        System.out.println();
        System.out.println("Materiales totales: " + servicio.contarMateriales(completa));
        System.out.println("Profundidad:        " + servicio.profundidad(completa));

        System.out.println();
        System.out.println(servicio.describirBusqueda(
                new ResultadoBusqueda.Encontrado(efectivo)));
        System.out.println(servicio.describirBusqueda(
                new ResultadoBusqueda.NoEncontrado("kotlin", List.of())));
        System.out.println(servicio.describirBusqueda(
                new ResultadoBusqueda.NoEncontrado("javaa", List.of("Java Efectivo"))));
        System.out.println(servicio.describirBusqueda(
                new ResultadoBusqueda.Ambiguo("java", List.of(efectivo, audio))));
    }
}

┌─ LIBRO ─────────────────────────────
│ Java Efectivo
│ Autor:      Joshua Bloch
│ Páginas:    412
│ Estante:    LIB-0000
│ Plazo:      21 días
│ Reposición: 32,96 €
└─────────────────────────────────────
┌─ REVISTA MENSUAL ───────────────────
│ Java Magazine nº 142 (AUGUST)
│ Estante:    REM-0000
│ Plazo:      7 días
└─────────────────────────────────────
┌─ AUDIOLIBRO ────────────────────────
│ Clean Code (audio)
│ Narrador:   D. Alonso
│ Duración:   480 min
│ Plazo:      21 días
└─────────────────────────────────────
┌─ COLECCIÓN ─────────────────────────
│ Biblioteca técnica Nexus
│ Elementos:  3 directos, 6 en total
│ Estante:    COL-1000
└─────────────────────────────────────

Materiales totales: 6
Profundidad:        2

Encontrado: Java Efectivo
No hay resultados para "kotlin"
No hay resultados para "javaa". ¿Quizás: Java Efectivo?
2 coincidencias para "java": Java Efectivo, Clean Code (audio)

public sealed abstract class Material
        implements ElementoCatalogo
        permits Libro, Revista, Dvd, AudioLibro, Mapa { }

public final class Mapa extends Material { /* ... */ }

ServicioCatalogo.java:14: error: the switch expression does not cover all possible input values
        return switch (material) {
               ^
ServicioCatalogo.java:27: error: the switch expression does not cover all possible input values
        return switch (material) {
               ^
ServicioCatalogo.java:37: error: the switch expression does not cover all possible input values
        String prefijo = switch (elemento) {
                         ^
ServicioCatalogo.java:49: error: the switch expression does not cover all possible input values
        return switch (elemento) {
               ^
4 errors

package com.nexussoftware.bibliotech.red;

import java.time.Duration;
import java.util.*;
import java.util.concurrent.*;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * Enriquecedor de catalogo con HILOS VIRTUALES.
 * Sustituye a la version de 09-06 basada en CompletableFuture.
 */
public class EnriquecedorVirtual implements AutoCloseable {

    private static final Logger LOG = Logger.getLogger(EnriquecedorVirtual.class.getName());

    /** Tipo suma para el resultado de cada ISBN. */
    public sealed interface ResultadoEnriquecimiento {
        String isbn();

        record Completo(String isbn, String metadatos, int bytesPortada, long ms)
                implements ResultadoEnriquecimiento { }

        record Parcial(String isbn, String metadatos, String motivoSinPortada, long ms)
                implements ResultadoEnriquecimiento { }

        record Fallido(String isbn, String motivo, long ms)
                implements ResultadoEnriquecimiento { }
    }

    /**
     * Semaforo, NO tamaño de pool: la restriccion es del servicio
     * externo, no de nuestros hilos.
     */
    private final Semaphore limiteExterno;

    private final ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();

    private final ClienteMetadatos metadatos;
    private final ClientePortadas portadas;

    public EnriquecedorVirtual(ClienteMetadatos metadatos, ClientePortadas portadas,
                               int peticionesSimultaneas) {
        this.metadatos = metadatos;
        this.portadas = portadas;
        this.limiteExterno = new Semaphore(peticionesSimultaneas);
    }

    public List<ResultadoEnriquecimiento> enriquecer(List<String> isbns) {

        List<Future<ResultadoEnriquecimiento>> futuros = new ArrayList<>(isbns.size());

        // Se lanzan TODAS: un hilo virtual por ISBN, sean 100 o 100.000
        for (String isbn : isbns) {
            futuros.add(executor.submit(() -> procesarUno(isbn)));
        }

        List<ResultadoEnriquecimiento> resultados = new ArrayList<>(isbns.size());
        for (int i = 0; i < futuros.size(); i++) {
            try {
                resultados.add(futuros.get(i).get());
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                break;
            } catch (ExecutionException e) {
                resultados.add(new ResultadoEnriquecimiento.Fallido(
                        isbns.get(i), "excepción no controlada: " + e.getCause(), 0));
            }
        }
        return resultados;
    }

    /**
     * CODIGO SECUENCIAL Y BLOQUEANTE. Ni un thenCompose, ni un
     * thenCombine, ni una retrollamada. Se lee de arriba abajo.
     */
    private ResultadoEnriquecimiento procesarUno(String isbn) {

        long inicio = System.nanoTime();
        Thread.currentThread().setName("enriquecer-" + isbn);

        try {
            // 1. Metadatos: bloquea, y no pasa nada
            String datos;
            limiteExterno.acquire();
            try {
                datos = metadatos.consultar(isbn);       // llamada BLOQUEANTE
            } finally {
                limiteExterno.release();
            }

            // 2. Portada: puede fallar sin invalidar el resultado
            int bytes;
            try {
                limiteExterno.acquire();
                try {
                    bytes = portadas.descargar(isbn).length;
                } finally {
                    limiteExterno.release();
                }
            } catch (Exception e) {
                return new ResultadoEnriquecimiento.Parcial(
                        isbn, datos, e.getClass().getSimpleName(), ms(inicio));
            }

            return new ResultadoEnriquecimiento.Completo(isbn, datos, bytes, ms(inicio));

        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return new ResultadoEnriquecimiento.Fallido(isbn, "interrumpido", ms(inicio));

        } catch (Exception e) {
            LOG.log(Level.FINE, e, () -> "Fallo al enriquecer " + isbn);
            return new ResultadoEnriquecimiento.Fallido(
                    isbn, e.getClass().getSimpleName() + ": " + e.getMessage(), ms(inicio));
        }
    }

    private long ms(long inicioNanos) {
        return (System.nanoTime() - inicioNanos) / 1_000_000;
    }

    /** Informe con switch exhaustivo sobre el tipo sellado. */
    public String informar(List<ResultadoEnriquecimiento> resultados) {

        Map<String, Long> porTipo = resultados.stream()
                .collect(java.util.stream.Collectors.groupingBy(
                        r -> switch (r) {
                            case ResultadoEnriquecimiento.Completo c -> "completos";
                            case ResultadoEnriquecimiento.Parcial p  -> "parciales";
                            case ResultadoEnriquecimiento.Fallido f  -> "fallidos";
                        },
                        java.util.TreeMap::new,
                        java.util.stream.Collectors.counting()));

        double mediaMs = resultados.stream()
                .mapToLong(r -> switch (r) {
                    case ResultadoEnriquecimiento.Completo c -> c.ms();
                    case ResultadoEnriquecimiento.Parcial p  -> p.ms();
                    case ResultadoEnriquecimiento.Fallido f  -> f.ms();
                })
                .average().orElse(0);

        return """
                Enriquecimiento de %d ISBN
                  %s
                  Duración media por ISBN: %.1f ms"""
                .formatted(resultados.size(), porTipo, mediaMs);
    }

    @Override
    public void close() {
        executor.close();        // ExecutorService es AutoCloseable desde Java 19
    }
}

package com.nexussoftware.bibliotech;

import java.time.Duration;
import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.locks.ReentrantLock;
import java.util.stream.IntStream;

public class ComparativaEnriquecimiento {

    /** Simula una llamada de red: 50 ms de espera. */
    private static String consultarSimulado(String isbn) throws InterruptedException {
        Thread.sleep(Duration.ofMillis(50));
        return "{\"isbn\":\"" + isbn + "\"}";
    }

    public static void main(String[] args) throws Exception {

        System.out.printf("%-10s %14s %14s %14s%n",
                "ISBN", "PLATAF. (200)", "VIRTUALES", "COMPL.FUTURE");
        System.out.println("-".repeat(56));

        for (int n : new int[] { 100, 1_000, 10_000 }) {
            List<String> isbns = generar(n);

            long plataforma = medir(() -> conPoolDePlataforma(isbns));
            long virtuales  = medir(() -> conHilosVirtuales(isbns));
            long futuros    = medir(() -> conCompletableFuture(isbns));

            System.out.printf("%-10d %11d ms %11d ms %11d ms%n",
                    n, plataforma, virtuales, futuros);
        }

        System.out.println();
        demostrarPinning();
    }

    private static List<String> generar(int n) {
        return IntStream.rangeClosed(1, n)
                .mapToObj(i -> String.format("978-%010d", i))
                .toList();
    }

    private static long medir(Runnable tarea) {
        long inicio = System.currentTimeMillis();
        tarea.run();
        return System.currentTimeMillis() - inicio;
    }

    private static void conPoolDePlataforma(List<String> isbns) {
        try (var executor = Executors.newFixedThreadPool(200)) {
            List<Future<String>> futuros = isbns.stream()
                    .map(isbn -> executor.submit(() -> consultarSimulado(isbn)))
                    .toList();
            futuros.forEach(ComparativaEnriquecimiento::obtener);
        }
    }

    private static void conHilosVirtuales(List<String> isbns) {
        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            List<Future<String>> futuros = isbns.stream()
                    .map(isbn -> executor.submit(() -> consultarSimulado(isbn)))
                    .toList();
            futuros.forEach(ComparativaEnriquecimiento::obtener);
        }
    }

    private static void conCompletableFuture(List<String> isbns) {
        try (var executor = Executors.newFixedThreadPool(200)) {
            List<CompletableFuture<String>> futuros = isbns.stream()
                    .map(isbn -> CompletableFuture.supplyAsync(() -> {
                        try {
                            return consultarSimulado(isbn);
                        } catch (InterruptedException e) {
                            Thread.currentThread().interrupt();
                            return null;
                        }
                    }, executor))
                    .toList();
            CompletableFuture.allOf(futuros.toArray(CompletableFuture[]::new)).join();
        }
    }

    private static <T> T obtener(Future<T> f) {
        try {
            return f.get();
        } catch (Exception e) {
            return null;
        }
    }

    // ------------------------------------------------------------------
    // Demostracion del PINNING
    // ------------------------------------------------------------------

    static class ConSynchronized {
        private final Map<String, String> cache = new HashMap<>();

        /** synchronized + bloqueo -> PINNING del hilo portador. */
        public synchronized String obtener(String isbn) throws InterruptedException {
            String v = cache.get(isbn);
            if (v == null) {
                v = consultarSimulado(isbn);
                cache.put(isbn, v);
            }
            return v;
        }
    }

    static class ConReentrantLock {
        private final Map<String, String> cache = new ConcurrentHashMap<>();
        private final ReentrantLock cerrojo = new ReentrantLock();

        /** ReentrantLock permite desmontar el hilo virtual. */
        public String obtener(String isbn) throws InterruptedException {
            String v = cache.get(isbn);
            if (v != null) {
                return v;
            }
            cerrojo.lock();
            try {
                v = cache.get(isbn);
                if (v == null) {
                    v = consultarSimulado(isbn);
                    cache.put(isbn, v);
                }
                return v;
            } finally {
                cerrojo.unlock();
            }
        }
    }

    private static void demostrarPinning() {
        System.out.println("--- Pinning (ejecutar con -Djdk.tracePinnedThreads=full) ---");
        List<String> isbns = generar(500);

        ConSynchronized conSync = new ConSynchronized();
        long t1 = medir(() -> {
            try (var e = Executors.newVirtualThreadPerTaskExecutor()) {
                isbns.forEach(isbn -> e.submit(() -> conSync.obtener(isbn)));
            }
        });

        ConReentrantLock conLock = new ConReentrantLock();
        long t2 = medir(() -> {
            try (var e = Executors.newVirtualThreadPerTaskExecutor()) {
                isbns.forEach(isbn -> e.submit(() -> conLock.obtener(isbn)));
            }
        });

        System.out.printf("  synchronized:  %5d ms%n", t1);
        System.out.printf("  ReentrantLock: %5d ms%n", t2);
    }
}

ISBN        PLATAF. (200)      VIRTUALES   COMPL.FUTURE
--------------------------------------------------------
100                  62 ms          58 ms          64 ms
1000                306 ms          71 ms         301 ms
10000              2571 ms         139 ms        2559 ms

--- Pinning (ejecutar con -Djdk.tracePinnedThreads=full) ---
  synchronized:  25142 ms
  ReentrantLock: 25089 ms

package com.nexussoftware.bibliotech.herramientas;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;
import java.util.*;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * Detecta oportunidades de modernizacion en codigo Java.
 *
 * Es un analisis por expresiones regulares: rapido y aproximado.
 * Un analizador real trabajaria sobre el AST (javax.lang.model, 10-02).
 */
public class AnalizadorDeModernizacion {

    /** Tipo sellado para las categorias de hallazgo. */
    public sealed interface Hallazgo {
        Path fichero();
        int linea();
        int versionJava();
        String sugerencia();

        record ConcatenacionMultilinea(Path fichero, int linea) implements Hallazgo {
            public int versionJava() { return 15; }
            public String sugerencia() { return "Usa un bloque de texto \"\"\"...\"\"\""; }
        }
        record SwitchClasico(Path fichero, int linea) implements Hallazgo {
            public int versionJava() { return 14; }
            public String sugerencia() { return "Usa switch de expresión con ->"; }
        }
        record CastTrasInstanceof(Path fichero, int linea, String tipo) implements Hallazgo {
            public int versionJava() { return 16; }
            public String sugerencia() { return "Usa instanceof " + tipo + " variable"; }
        }
        record ApiDeFechasAntigua(Path fichero, int linea, String clase) implements Hallazgo {
            public int versionJava() { return 8; }
            public String sugerencia() {
                return switch (clase) {
                    case "SimpleDateFormat" -> "Usa DateTimeFormatter (inmutable y seguro entre hilos)";
                    case "Calendar"         -> "Usa LocalDate / LocalDateTime";
                    case "Date"             -> "Usa Instant o LocalDate según el caso";
                    default                 -> "Migra a java.time";
                };
            }
        }
        record PoolDePlataforma(Path fichero, int linea) implements Hallazgo {
            public int versionJava() { return 21; }
            public String sugerencia() {
                return "Si las tareas se bloquean, usa Executors.newVirtualThreadPerTaskExecutor()";
            }
        }
        record BucleAcumulador(Path fichero, int linea) implements Hallazgo {
            public int versionJava() { return 8; }
            public String sugerencia() { return "Considera stream().filter(...).map(...).toList()"; }
        }
        record CandidatoARecord(Path fichero, int linea, String clase) implements Hallazgo {
            public int versionJava() { return 16; }
            public String sugerencia() { return "La clase " + clase + " podría ser un record"; }
        }
    }

    // --- Patrones ---
    private static final Pattern CONCATENACION = Pattern.compile("^\\s*\\+\\s*\"");
    private static final Pattern SWITCH_CLASICO = Pattern.compile("\\bcase\\s+[^>]+:\\s*$");
    private static final Pattern INSTANCEOF_SIN_PATRON =
            Pattern.compile("instanceof\\s+(\\w+)\\s*\\)\\s*\\{?\\s*$");
    private static final Pattern CAST = Pattern.compile("\\(\\s*(\\w+)\\s*\\)\\s*\\w+");
    private static final Pattern FECHAS_ANTIGUAS =
            Pattern.compile("\\bnew\\s+(SimpleDateFormat|Date|GregorianCalendar)\\b"
                          + "|\\bCalendar\\.getInstance\\(\\)");
    private static final Pattern POOL_FIJO =
            Pattern.compile("Executors\\.newFixedThreadPool|Executors\\.newCachedThreadPool");
    private static final Pattern DECLARACION_LISTA =
            Pattern.compile("(List|Set|Map)<[^>]+>\\s+\\w+\\s*=\\s*new\\s+(ArrayList|HashSet|HashMap)");
    private static final Pattern FOR_EACH = Pattern.compile("\\bfor\\s*\\(\\s*\\w+.*:\\s*\\w+");

    public List<Hallazgo> analizar(Path raiz) throws IOException {
        try (Stream<Path> ficheros = Files.walk(raiz)) {
            return ficheros
                    .filter(Files::isRegularFile)
                    .filter(p -> p.toString().endsWith(".java"))
                    .filter(p -> !p.getFileName().toString().equals("module-info.java"))
                    .flatMap(this::analizarFichero)
                    .toList();
        }
    }

    private Stream<Hallazgo> analizarFichero(Path fichero) {
        try {
            List<String> lineas = Files.readAllLines(fichero, StandardCharsets.UTF_8);
            List<Hallazgo> hallazgos = new ArrayList<>();

            String posibleTipoInstanceof = null;
            int lineaInstanceof = 0;
            int lineasDeDeclaracion = 0;
            int inicioDeclaracion = 0;

            for (int i = 0; i < lineas.size(); i++) {
                String linea = lineas.get(i);
                int numero = i + 1;

                if (CONCATENACION.matcher(linea).find()) {
                    hallazgos.add(new Hallazgo.ConcatenacionMultilinea(fichero, numero));
                }
                if (SWITCH_CLASICO.matcher(linea).find()) {
                    hallazgos.add(new Hallazgo.SwitchClasico(fichero, numero));
                }
                if (FECHAS_ANTIGUAS.matcher(linea).find()) {
                    var m = FECHAS_ANTIGUAS.matcher(linea);
                    m.find();
                    String clase = m.group(1) != null ? m.group(1) : "Calendar";
                    hallazgos.add(new Hallazgo.ApiDeFechasAntigua(fichero, numero, clase));
                }
                if (POOL_FIJO.matcher(linea).find()) {
                    hallazgos.add(new Hallazgo.PoolDePlataforma(fichero, numero));
                }

                // instanceof en una linea, cast al mismo tipo en la siguiente
                var mi = INSTANCEOF_SIN_PATRON.matcher(linea);
                if (mi.find()) {
                    posibleTipoInstanceof = mi.group(1);
                    lineaInstanceof = numero;
                } else if (posibleTipoInstanceof != null) {
                    var mc = CAST.matcher(linea);
                    if (mc.find() && posibleTipoInstanceof.equals(mc.group(1))) {
                        hallazgos.add(new Hallazgo.CastTrasInstanceof(
                                fichero, lineaInstanceof, posibleTipoInstanceof));
                    }
                    posibleTipoInstanceof = null;
                }

                // Declaracion de coleccion seguida de bucle for-each: candidato a stream
                if (DECLARACION_LISTA.matcher(linea).find()) {
                    lineasDeDeclaracion = 1;
                    inicioDeclaracion = numero;
                } else if (lineasDeDeclaracion > 0 && lineasDeDeclaracion < 4) {
                    if (FOR_EACH.matcher(linea).find()) {
                        hallazgos.add(new Hallazgo.BucleAcumulador(fichero, inicioDeclaracion));
                        lineasDeDeclaracion = 0;
                    } else {
                        lineasDeDeclaracion++;
                    }
                } else {
                    lineasDeDeclaracion = 0;
                }
            }

            detectarCandidatoARecord(fichero, lineas).ifPresent(hallazgos::add);
            return hallazgos.stream();

        } catch (IOException e) {
            System.err.println("No se pudo leer " + fichero + ": " + e.getMessage());
            return Stream.empty();
        }
    }

    /** Heuristica: solo campos final, getters, equals, hashCode y toString. */
    private Optional<Hallazgo> detectarCandidatoARecord(Path fichero, List<String> lineas) {
        String contenido = String.join("\n", lineas);

        boolean tieneSetters = contenido.contains("public void set");
        boolean tieneCamposNoFinales = Pattern
                .compile("private\\s+(?!final)\\w+\\s+\\w+\\s*;").matcher(contenido).find();
        boolean tieneEquals = contenido.contains("public boolean equals(Object");
        boolean tieneHashCode = contenido.contains("public int hashCode()");
        boolean extiende = Pattern.compile("class\\s+\\w+\\s+extends").matcher(contenido).find();

        if (!tieneSetters && !tieneCamposNoFinales && tieneEquals && tieneHashCode && !extiende) {
            String nombre = fichero.getFileName().toString().replace(".java", "");
            int linea = 1 + (int) lineas.stream()
                    .takeWhile(l -> !l.contains("class " + nombre))
                    .count();
            return Optional.of(new Hallazgo.CandidatoARecord(fichero, linea, nombre));
        }
        return Optional.empty();
    }

    // ------------------------------------------------------------------

    public String informar(List<Hallazgo> hallazgos, int versionObjetivo) {

        Map<String, List<Hallazgo>> porTipo = hallazgos.stream()
                .collect(Collectors.groupingBy(h -> h.getClass().getSimpleName(),
                         TreeMap::new, Collectors.toList()));

        Map<Integer, Long> porVersion = hallazgos.stream()
                .collect(Collectors.groupingBy(Hallazgo::versionJava,
                         TreeMap::new, Collectors.counting()));

        long aplicables = hallazgos.stream()
                .filter(h -> h.versionJava() <= versionObjetivo)
                .count();

        StringBuilder sb = new StringBuilder();
        sb.append("""
                ════════════════════════════════════════════════════
                  INFORME DE MODERNIZACIÓN -- objetivo: Java %d
                ════════════════════════════════════════════════════
                  Hallazgos totales:     %d
                  Aplicables ya:         %d
                  Requieren migrar:      %d
                """.formatted(versionObjetivo, hallazgos.size(),
                              aplicables, hallazgos.size() - aplicables));

        sb.append("\nPOR VERSIÓN MÍNIMA NECESARIA\n");
        porVersion.forEach((v, n) -> sb.append(String.format(
                "  Java %-3d %4d  %s%s%n", v, n, "▇".repeat((int) Math.min(n, 40)),
                v <= versionObjetivo ? "" : "   (requiere migrar)")));

        sb.append("\nPOR TIPO\n");
        porTipo.forEach((tipo, lista) -> {
            sb.append(String.format("  %-26s %4d%n", tipo, lista.size()));
            lista.stream().limit(3).forEach(h -> sb.append(String.format(
                    "      %s:%d  %s%n",
                    h.fichero().getFileName(), h.linea(), h.sugerencia())));
            if (lista.size() > 3) {
                sb.append(String.format("      ... y %d más%n", lista.size() - 3));
            }
        });

        return sb.toString();
    }

    public static void main(String[] args) throws IOException {
        Path raiz = Path.of(args.length > 0 ? args[0] : "src");
        int objetivo = args.length > 1 ? Integer.parseInt(args[1]) : 21;

        AnalizadorDeModernizacion analizador = new AnalizadorDeModernizacion();
        List<Hallazgo> hallazgos = analizador.analizar(raiz);

        System.out.println(analizador.informar(hallazgos, objetivo));
    }
}

════════════════════════════════════════════════════
  INFORME DE MODERNIZACIÓN -- objetivo: Java 21
════════════════════════════════════════════════════
  Hallazgos totales:     47
  Aplicables ya:         47
  Requieren migrar:      0

POR VERSIÓN MÍNIMA NECESARIA
  Java 8     14  ▇▇▇▇▇▇▇▇▇▇▇▇▇▇
  Java 14     9  ▇▇▇▇▇▇▇▇▇
  Java 15    11  ▇▇▇▇▇▇▇▇▇▇▇
  Java 16     8  ▇▇▇▇▇▇▇▇
  Java 21     5  ▇▇▇▇▇

POR TIPO
  ApiDeFechasAntigua          9
      GestorSesion.java:34  Usa DateTimeFormatter (inmutable y seguro entre hilos)
      AlmacenPrestamos.java:57  Usa LocalDate / LocalDateTime
      RegistroOperaciones.java:22  Usa Instant o LocalDate según el caso
      ... y 6 más
  BucleAcumulador             5
      EstadisticasBiblioTech.java:19  Considera stream().filter(...).map(...).toList()
      MenuBiblioTech.java:88  Considera stream().filter(...).map(...).toList()
      ... y 3 más
  CandidatoARecord            3
      Ficha.java:8  La clase Ficha podría ser un record
      ResumenSesion.java:11  La clase ResumenSesion podría ser un record
      ... y 1 más
  CastTrasInstanceof          8
      CalculadoraPlazosAntigua.java:14  Usa instanceof Libro variable
      ExportadorCatalogoCsv.java:41  Usa instanceof Material variable
      ... y 6 más
  ConcatenacionMultilinea    11
      ConsultasBiblioTech.java:12  Usa un bloque de texto """..."""
      ClienteMetadatos.java:73  Usa un bloque de texto """..."""
      ... y 9 más
  PoolDePlataforma            5
      ServidorCatalogoConPool.java:24  Si las tareas se bloquean, usa Executors.newVirtualThreadPerTaskExecutor()
      ... y 4 más
  SwitchClasico               6
      MenuBiblioTech.java:52  Usa switch de expresión con ->
      ... y 5 más