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

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
      domini/
      servei/
      persistencia/
      xarxa/
      intern/

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

    // --- QUE NECESSITO ---
    requires java.logging;              // java.util.logging (06-07)
    requires java.net.http;             // HttpClient (09-06)
    requires java.sql;                  // JDBC, per al modul 11

    // transitive: qui em requereixi obte tambe aixo
    requires transitive com.nexussoftware.comu;

    // static: necessari per compilar, opcional en execucio
    requires static com.nexussoftware.eines;

    // --- QUE OFEREIXO ---
    exports com.nexussoftware.bibliotech.domini;
    exports com.nexussoftware.bibliotech.servei;

    // Exportacio qualificada: NOMES a aquests moduls
    exports com.nexussoftware.bibliotech.persistencia
            to com.nexussoftware.bibliotech.proves;

    // com.nexussoftware.bibliotech.intern NO s exporta:
    // es inaccessible des de fora encara que les seves classes siguin public

    // --- REFLEXIO ---
    // opens permet reflexio PROFUNDA (setAccessible sobre privats)
    opens com.nexussoftware.bibliotech.domini;

    // Obertura qualificada
    opens com.nexussoftware.bibliotech.persistencia to com.fasterxml.jackson.databind;

    // --- SERVEIS (ServiceLoader) ---
    uses com.nexussoftware.bibliotech.servei.PoliticaMultes;
    provides com.nexussoftware.bibliotech.servei.PoliticaMultes
            with com.nexussoftware.bibliotech.intern.PoliticaEstandard;
}

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

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

# Obrir un paquet concret a tot el codi sense modul
java --add-opens java.base/java.lang=ALL-UNNAMED -cp app.jar com.exemple.App

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

# Diverses alhora
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.domini;

    // El nostre ExportadorAnotat de 10-03 fa setAccessible sobre
    // els camps privats de les entitats: necessita opens.
    opens com.nexussoftware.bibliotech.domini;
}

# CLASSPATH: mode classic. Tot va al "modul sense nom".
javac -cp lib/*.jar -d classes $(find src -name "*.java")
java -cp classes:lib/*.jar com.nexussoftware.bibliotech.BiblioTechApp

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

# Descobrir quins moduls necessita l aplicacio
jdeps --print-module-deps --ignore-missing-deps classes/bibliotech.jar

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

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

# I executar hi
./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> empleats = List.of("Marta Ruiz", "Diego Alonso", "Nuria Vidal");
Set<String> isbns = Set.of("978-0000000001", "978-0000000002");
Map<String, Integer> prestecs = Map.of("Marta Ruiz", 4, "Diego Alonso", 2);

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

// Copia immutable d una colleccio existent (Java 10)
List<String> copia = List.copyOf(llistaModificable);

Set<String> conjunt = Set.of("a", "b", "c", "d");
System.out.println(conjunt);   // ordre diferent a cada execucio del programa

public interface ServeiPrestecs {

    Resultat<Prestec> prestar(String isbn, String empleat);

    default Resultat<Prestec> prestarValidant(String isbn, String empleat) {
        if (!esIsbnValid(isbn)) {
            return Resultat.fallada("ISBN mal format: " + isbn);
        }
        if (!esEmpleatValid(empleat)) {
            return Resultat.fallada("Empleat no valid");
        }
        return prestar(isbn, empleat);
    }

    // PRIVAT: logica compartida entre els default, invisible des de fora
    private boolean esIsbnValid(String isbn) {
        return isbn != null && isbn.matches("978-\\d{10}");
    }

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

String titol = "  Java Eficac  ";

System.out.println(titol.strip());            // "Java Eficac"  (Unicode-aware)
System.out.println(titol.stripLeading());     // "Java Eficac  "
System.out.println(titol.stripTrailing());    // "  Java Eficac"
System.out.println("   ".isBlank());          // true
System.out.println("".isEmpty());             // true
System.out.println("=".repeat(40));           // linia separadora
System.out.println("un\ndos".lines().count()); // 2  (retorna Stream<String>)
System.out.println("text".indent(4));         // sagnat (Java 12)

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

// ABANS
List<String> linies = Files.readAllLines(cami, StandardCharsets.UTF_8);
String contingut = String.join("\n", linies);

// ARA
String contingut = Files.readString(cami, StandardCharsets.UTF_8);
Files.writeString(cami, contingut, StandardCharsets.UTF_8);

List<Llibre> cataleg = new ArrayList<>(...);

// ABANS: cada colleccio tenia la seva forma
Llibre primer = cataleg.get(0);
Llibre ultim = cataleg.get(cataleg.size() - 1);
Llibre primerDeque = deque.getFirst();
Llibre primerSet = conjuntOrdenat.iterator().next();        // aixi!

// ARA: SequencedCollection unifica
Llibre primer2 = cataleg.getFirst();
Llibre ultim2 = cataleg.getLast();
cataleg.addFirst(nou);
cataleg.addLast(altre);
List<Llibre> alReves = cataleg.reversed();                  // vista, no copia

// I funciona igual a LinkedHashSet, TreeSet, Deque, LinkedHashMap
LinkedHashMap<String, Llibre> perIsbn = new LinkedHashMap<>();
var primeraEntrada = perIsbn.firstEntry();

String editorial = cataleg.cercarPerIsbn(isbn).getEditorial().getNom().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.domini.Editorial.getNom()" is null
    at com.nexussoftware.bibliotech.BiblioTechApp.main(BiblioTechApp.java:42)

var cataleg = new ArrayList<Llibre>();                  // ArrayList<Llibre>
var titol = "Java Eficac";                              // String
var pagines = 412;                                      // int
var data = LocalDate.of(2026, 8, 5);                    // LocalDate

// On mes brilla: tipus generics llargs
var perEmpleatITipus = new HashMap<String, Map<TipusMaterial, List<Prestec>>>();

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

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

var titol = "Java Eficac";
// titol = 42;          // NO COMPILA: String no admet int

// var camp = "x";                  // camps de classe: NO
// public var metode() { }          // retorn de metode: NO
// void m(var parametre) { }        // parametres: NO (tret de les lambdes, Java 11)
// var senseValor;                  // sense inicialitzador: NO
// var nul = null;                  // no hi ha res a inferir: NO
// var array = { 1, 2, 3 };         // inicialitzador d array: NO

// BE: el tipus es evident pel costat dret
var cataleg = new ArrayList<Llibre>();
var reserva = new Reserva("R-001", "Madrid-A", "Marta Ruiz", inici, durada);
var comptador = new AtomicInteger(0);

// BE: el tipus explicit seria illegible
var index = new HashMap<String, Map<TipusMaterial, List<Prestec>>>();

// MALAMENT: el tipus no es dedueix del nom del metode
var resultat = servei.processar(dades);        // que es 'resultat'?
var x = calcular();                             // int? double? BigDecimal?

// MALAMENT: es perd l abstraccio a la interficie
var llista = new ArrayList<Llibre>();           // el tipus es ArrayList
List<Llibre> llista2 = new ArrayList<>();       // el tipus es List: millor API

// PERILLOS: el diamant buit infereix Object
var buida = new ArrayList<>();                  // ArrayList<Object>

llista.forEach((@NoNul var llibre) -> System.out.println(llibre.getTitol()));

// CLASSIC: verbos i amb paranys
String descripcio;
switch (gravetat) {
    case ALTA:
        descripcio = "Requereix intervencio immediata";
        break;
    case MITJANA:
        descripcio = "Revisar aquesta setmana";
        break;
    case BAIXA:
        descripcio = "Anotar i continuar";
        break;
    default:
        throw new IllegalStateException("Gravetat desconeguda: " + gravetat);
}

// EXPRESSIO: retorna un valor, sense break, sense caiguda
String descripcio = switch (gravetat) {
    case ALTA    -> "Requereix intervencio immediata";
    case MITJANA -> "Revisar aquesta setmana";
    case BAIXA   -> "Anotar i continuar";
};

double multa = switch (gravetat) {
    case ALTA -> {
        double base = dies * 0.50;
        double recarrec = dies > 30 ? 10.0 : 0.0;
        yield Math.min(base + recarrec, 50.0);     // yield retorna el valor del bloc
    }
    case MITJANA -> dies * 0.25;
    case BAIXA -> 0.0;
};

int diesDeTermini = switch (tipus) {
    case "LLIBRE"  -> 21;
    case "REVISTA" -> 7;
    case "DVD"     -> 3;
    default -> throw new IllegalArgumentException("Tipus desconegut: " + tipus);
};

// ABANS: illegible, amb escapaments i concatenacio
String json = "{\n"
        + "  \"isbn\": \"978-0000000001\",\n"
        + "  \"titol\": \"Java Eficac\",\n"
        + "  \"disponible\": true\n"
        + "}";

// ARA
String json = """
        {
          "isbn": "978-0000000001",
          "titol": "Java Eficac",
          "disponible": true
        }""";

public class Exemple {
    public String consulta() {
        String sql = """
                SELECT p.referencia, p.isbn, m.titol
                  FROM prestecs p
                  JOIN materials m ON m.isbn = p.isbn
                 WHERE p.data_devolucio IS NULL
                 ORDER BY p.data_venciment
                """;
        return sql;
    }
}

// El tancament a l esquerra del contingut: es conserva mes sagnat
String a = """
        linia
  """;                    // el marge comu es 2: "      linia\n"

// El tancament alineat amb el contingut: s elimina tot el sagnat
String b = """
        linia
        """;              // el marge comu es 8: "linia\n"

// El tancament a la mateixa linia: sense salt final
String c = """
        linia""";         // "linia"  (sense \n al final)

// \ al final de linia: UNEIX les linies (sense salt)
String unaSolaLinia = """
        Aquest text esta escrit en diverses linies \
        del codi font pero es una sola \
        linia de resultat.""";

// \s: espai que NO s elimina com a sagnat final
String ambEspais = """
        columna1   \s
        columna2   \s""";

public class ConsultesBiblioTech {

    static final String PRESTECS_VENCUTS = """
            SELECT p.referencia,
                   p.isbn,
                   m.titol,
                   p.empleat,
                   p.data_venciment,
                   CURRENT_DATE - p.data_venciment AS dies_retard
              FROM prestecs p
              JOIN materials m ON m.isbn = p.isbn
             WHERE p.data_devolucio IS NULL
               AND p.data_venciment < CURRENT_DATE
             ORDER BY dies_retard DESC
            """;

    static String peticioDeMetadades(String isbn) {
        return """
                {
                  "jsonrpc": "2.0",
                  "method": "cataleg.cercar",
                  "params": { "isbn": "%s" },
                  "id": 1
                }""".formatted(isbn);          // formatted: com String.format
    }
}

public record Fitxa(String isbn, String titol, boolean disponible) { }

public record Prestec(String referencia, String isbn, String empleat,
                      LocalDate dataPrestec, LocalDate dataVenciment) {

    /** Constructor COMPACTE: valida i normalitza abans d assignar. */
    public Prestec {
        Objects.requireNonNull(referencia, "referencia");
        Objects.requireNonNull(isbn, "isbn");
        if (dataVenciment.isBefore(dataPrestec)) {
            throw new IllegalArgumentException("Venciment anterior al prestec");
        }
        empleat = empleat.strip();         // es pot NORMALITZAR el parametre
    }

    /** Constructor addicional. */
    public Prestec(String referencia, String isbn, String empleat, LocalDate des) {
        this(referencia, isbn, empleat, des, des.plusDays(21));
    }

    /** Metodes derivats. */
    public long diesDeRetard(LocalDate avui) {
        return Math.max(0, ChronoUnit.DAYS.between(dataVenciment, avui));
    }

    /** "Modificar" un record = crear ne un altre. */
    public Prestec ambVenciment(LocalDate nou) {
        return new Prestec(referencia, isbn, empleat, dataPrestec, nou);
    }

    /** Metodes i camps estatics SI que es permeten. */
    public static final Period TERMINI = Period.ofDays(21);

    public static Prestec nou(String ref, String isbn, String empleat, LocalDate des) {
        return new Prestec(ref, isbn, empleat, des, des.plus(TERMINI));
    }
}

// ABANS: la conversio repeteix el que l instanceof ja va comprovar
if (material instanceof Llibre) {
    Llibre llibre = (Llibre) material;
    System.out.println(llibre.getPagines());
}

// ARA: la variable de patro es declara i s assigna alhora
if (material instanceof Llibre llibre) {
    System.out.println(llibre.getPagines());
}

// Amb && : la variable esta disponible a la dreta
if (material instanceof Llibre llibre && llibre.getPagines() > 400) {
    System.out.println("Llibre llarg: " + llibre.getTitol());
}

// Amb negacio: disponible DESPRES de l if (sortida primerenca)
public String descriure(Object objecte) {
    if (!(objecte instanceof Material material)) {
        return "No es un material";
    }
    // 'material' esta en ambit aqui, perque si no ho estigues ja hauriem tornat
    return material.getTitol() + " (" + material.getTipus() + ")";
}

// Amb || : NO esta disponible, i el compilador ho impedeix
// if (o instanceof Llibre l || l.getPagines() > 0) { }   // NO COMPILA

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

// En un altre projecte, sense que ningu ho aprovi
public class Videojoc extends Material { }

package com.nexussoftware.bibliotech.domini;

/**
 * Jerarquia TANCADA: nomes existeixen aquests tres materials.
 * Cap altra classe no pot estendre Material, ni en aquest
 * projecte ni en cap.
 */
public sealed abstract class Material
        permits Llibre, Revista, Dvd {

    private final String isbn;
    private final String titol;

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

    public String getIsbn()  { return isbn; }
    public String getTitol() { return titol; }

    public abstract TipusMaterial getTipus();
}

/** final: ningu no esten Llibre. Es el mes habitual. */
public final class Llibre extends Material {
    private final int pagines;
    private final String autor;
    // ...
}

/** sealed: Revista te al seu torn una jerarquia tancada. */
public sealed class Revista extends Material permits RevistaMensual, RevistaTrimestral {
    // ...
}

/** non-sealed: Dvd torna a estar obert a qualsevol. */
public non-sealed class Dvd extends Material {
    // ...
}

// Tot en un fitxer: permits implicit
public sealed interface Esdeveniment {
    record Prestat(String isbn, String empleat, LocalDate quan) implements Esdeveniment { }
    record Retornat(String isbn, LocalDate quan, boolean ambRetard) implements Esdeveniment { }
    record Perdut(String isbn, String empleat, double quantitat) implements Esdeveniment { }
}

// SENSE default: el compilador comprova que hi son els tres
String etiqueta = switch (material) {
    case Llibre l  -> "Llibre de " + l.getPagines() + " pagines";
    case Revista r -> "Revista num. " + r.getNumero();
    case Dvd d     -> "DVD de " + d.getMinuts() + " minuts";
};

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

package com.nexussoftware.bibliotech.domini;

import java.time.LocalDate;

/**
 * Estat d un prestec modelat com a tipus suma.
 * Cada estat porta EXACTAMENT les dades que te sentit
 * que porti, en lloc d una classe amb camps que de vegades son null.
 */
public sealed interface EstatPrestec {

    record Actiu(LocalDate venciment) implements EstatPrestec { }

    record Vencut(LocalDate venciment, long diesDeRetard, double multa)
            implements EstatPrestec { }

    record Retornat(LocalDate quan, boolean puntual) implements EstatPrestec { }

    record Perdut(LocalDate declaratEl, double quantitatReposicio)
            implements EstatPrestec { }
}

// ABANS: cadena d instanceof, amb conversio a cada branca
public String descriure(Object objecte) {
    if (objecte instanceof Llibre) {
        Llibre l = (Llibre) objecte;
        return "Llibre: " + l.getTitol() + " (" + l.getPagines() + " pags.)";
    } else if (objecte instanceof Revista) {
        Revista r = (Revista) objecte;
        return "Revista: " + r.getTitol() + " num. " + r.getNumero();
    } else if (objecte instanceof Dvd) {
        Dvd d = (Dvd) objecte;
        return "DVD: " + d.getTitol() + " (" + d.getMinuts() + " min)";
    } else if (objecte == null) {
        return "(res)";
    }
    return "Desconegut";
}

// ARA
public String descriure(Object objecte) {
    return switch (objecte) {
        case null      -> "(res)";
        case Llibre l  -> "Llibre: " + l.getTitol() + " (" + l.getPagines() + " pags.)";
        case Revista r -> "Revista: " + r.getTitol() + " num. " + r.getNumero();
        case Dvd d     -> "DVD: " + d.getTitol() + " (" + d.getMinuts() + " min)";
        default        -> "Desconegut: " + objecte.getClass().getSimpleName();
    };
}

public String classificar(Material material) {
    return switch (material) {
        case Llibre l when l.getPagines() > 500 -> "Llibre extens";
        case Llibre l when l.getPagines() > 200 -> "Llibre estandard";
        case Llibre l                           -> "Llibre breu";
        case Revista r when r.esEspecial()      -> "Numero especial";
        case Revista r                          -> "Revista ordinaria";
        case Dvd d                              -> "Material audiovisual";
    };
}

case Llibre l                           -> "...";
case Llibre l when l.getPagines() > 500 -> "...";   // ERROR: inabastable

public sealed interface Esdeveniment {
    record Prestat(String isbn, String empleat, LocalDate quan) implements Esdeveniment { }
    record Retornat(String isbn, LocalDate quan, boolean ambRetard) implements Esdeveniment { }
    record Perdut(String isbn, String empleat, double quantitat) implements Esdeveniment { }
}

public String registrar(Esdeveniment esdeveniment) {
    return switch (esdeveniment) {

        // Es DESCOMPON el record: isbn, empleat i quan surten directament
        case Esdeveniment.Prestat(String isbn, String empleat, LocalDate quan) ->
                String.format("%s va prestar %s el %s", empleat, isbn, quan);

        // Amb guarda sobre un component descompost
        case Esdeveniment.Retornat(String isbn, LocalDate quan, boolean retard) when retard ->
                String.format("%s retornat el %s AMB RETARD", isbn, quan);

        case Esdeveniment.Retornat(String isbn, LocalDate quan, boolean retard) ->
                String.format("%s retornat puntualment el %s", isbn, quan);

        case Esdeveniment.Perdut(String isbn, String empleat, double quantitat) ->
                String.format("%s va declarar perdut %s (reposicio: %.2f €)",
                        empleat, isbn, quantitat);
    };
    // SENSE default: la interficie es sealed i hi son els tres casos
}

case Esdeveniment.Prestat(var isbn, var empleat, var quan) ->
        empleat + " va prestar " + isbn + " el " + quan;

public record Punt(int x, int y) { }
public record Linia(Punt inici, Punt fi) { }

public String descriure(Object o) {
    return switch (o) {
        // Descomposicio IMBRICADA en dos nivells
        case Linia(Punt(var x1, var y1), Punt(var x2, var y2)) when x1 == x2 ->
                "Linia vertical a x=" + x1;
        case Linia(Punt(var x1, var y1), Punt(var x2, var y2)) when y1 == y2 ->
                "Linia horitzontal a y=" + y1;
        case Linia(Punt p1, Punt p2) ->
                "Linia de " + p1 + " a " + p2;
        case Punt(int x, int y) ->
                "Punt (" + x + ", " + y + ")";
        default -> "Una altra cosa";
    };
}

if (esdeveniment instanceof Esdeveniment.Prestat(String isbn, String empleat, LocalDate quan)) {
    System.out.println(empleat + " -> " + isbn + " (" + quan + ")");
}

package com.nexussoftware.bibliotech.servei;

import com.nexussoftware.bibliotech.domini.*;

/**
 * VERSIO ANTIGA: jerarquia oberta, conversions manuals,
 * cadenes d if-else i un default que amaga els casos nous.
 */
public class CalculadoraTerminisAntiga {

    public int diesDeTermini(Material material) {
        if (material instanceof Llibre) {
            Llibre llibre = (Llibre) material;
            if (llibre.getPagines() > 500) {
                return 30;
            } else if (llibre.getPagines() > 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;
        }
        // I si algu afegeix un tipus nou, cau AQUI en silenci
        throw new IllegalArgumentException("Tipus desconegut: " + material.getClass());
    }

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

    public double valorDeReposicio(Material material) {
        if (material instanceof Llibre) {
            return ((Llibre) material).getPagines() * 0.08;
        } else if (material instanceof Revista) {
            return 12.0;
        } else if (material instanceof Dvd) {
            return ((Dvd) material).getMinuts() * 0.15;
        }
        return 0.0;
    }
}

package com.nexussoftware.bibliotech.domini;

/** Jerarquia SEGELLADA: el compilador sap que nomes existeixen tres materials. */
public sealed abstract class Material permits Llibre, Revista, Dvd {

    private final String isbn;
    private final String titol;
    private final double valoracio;

    protected Material(String isbn, String titol, double valoracio) {
        this.isbn = isbn;
        this.titol = titol;
        this.valoracio = valoracio;
    }

    public String getIsbn()     { return isbn; }
    public String getTitol()    { return titol; }
    public double getValoracio() { return valoracio; }
}

public final class Llibre extends Material {
    private final int pagines;
    private final String autor;

    public Llibre(String isbn, String titol, String autor, int pagines, double valoracio) {
        super(isbn, titol, valoracio);
        this.autor = autor;
        this.pagines = pagines;
    }
    public int getPagines()  { return pagines; }
    public String getAutor() { return autor; }
}

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

    public Revista(String isbn, String titol, int numero, boolean especial, double valoracio) {
        super(isbn, titol, valoracio);
        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 minuts;
    private final String director;

    public Dvd(String isbn, String titol, String director, int minuts, double valoracio) {
        super(isbn, titol, valoracio);
        this.director = director;
        this.minuts = minuts;
    }
    public int getMinuts()      { return minuts; }
    public String getDirector() { return director; }
}

package com.nexussoftware.bibliotech.servei;

import com.nexussoftware.bibliotech.domini.*;

/**
 * VERSIO MODERNA: switch exhaustiu sense default,
 * sense conversions, amb guardes. Si s afegeix un quart material,
 * AQUESTS TRES METODES DEIXEN DE COMPILAR i el compilador
 * et porta a cadascun.
 */
public class CalculadoraTerminis {

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

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

    public double valorDeReposicio(Material material) {
        return switch (material) {
            case Llibre l  -> l.getPagines() * 0.08;
            case Revista r -> r.esEspecial() ? 25.0 : 12.0;
            case Dvd d     -> d.getMinuts() * 0.15;
        };
    }

    /** Amb blocs i yield quan hi ha logica. */
    public String fitxaCompleta(Material material) {
        return switch (material) {
            case Llibre l -> {
                String extensio = l.getPagines() > 400 ? "extens" : "estandard";
                yield """
                        LLIBRE
                          Titol:      %s
                          Autor:      %s
                          Pagines:    %d (%s)
                          Termini:    %d dies
                          Reposicio:  %.2f €"""
                        .formatted(l.getTitol(), l.getAutor(), l.getPagines(),
                                   extensio, diesDeTermini(l), valorDeReposicio(l));
            }
            case Revista r -> """
                    REVISTA
                      Titol:      %s
                      Numero:     %d%s
                      Termini:    %d dies"""
                    .formatted(r.getTitol(), r.getNumero(),
                               r.esEspecial() ? " (ESPECIAL)" : "", diesDeTermini(r));
            case Dvd d -> """
                    DVD
                      Titol:      %s
                      Director:   %s
                      Durada:     %d min
                      Termini:    %d dies"""
                    .formatted(d.getTitol(), d.getDirector(), d.getMinuts(), diesDeTermini(d));
        };
    }
}

package com.nexussoftware.bibliotech.servei;

import com.nexussoftware.bibliotech.domini.EstatPrestec;

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

public class DescriptorEstat {

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

    public String descriure(EstatPrestec estat) {
        return switch (estat) {

            case EstatPrestec.Actiu(var venciment) ->
                    "Actiu, venc el " + venciment.format(DATA);

            case EstatPrestec.Vencut(var venciment, var dies, var multa) when multa == 0 ->
                    "Vencut fa " + dies + " dies (encara en periode de cortesia)";

            case EstatPrestec.Vencut(var venciment, var dies, var multa) ->
                    String.format("VENCUT fa %d dies -- multa acumulada: %.2f €", dies, multa);

            case EstatPrestec.Retornat(var quan, var puntual) ->
                    "Retornat el " + quan.format(DATA) + (puntual ? " puntualment" : " amb retard");

            case EstatPrestec.Perdut(var declarat, var quantitat) ->
                    String.format("PERDUT des del %s -- reposicio: %.2f €",
                            declarat.format(DATA), quantitat);
        };
    }

    /** Prioritat de gestio: un switch que retorna un int. */
    public int prioritat(EstatPrestec estat) {
        return switch (estat) {
            case EstatPrestec.Perdut p                                 -> 100;
            case EstatPrestec.Vencut(var v, var dies, var m) when dies > 30 -> 90;
            case EstatPrestec.Vencut v                                 -> 50;
            case EstatPrestec.Actiu a                                  -> 10;
            case EstatPrestec.Retornat r                               -> 0;
        };
    }
}

List<EstatPrestec> estats = List.of(
        new EstatPrestec.Actiu(LocalDate.of(2026, 8, 26)),
        new EstatPrestec.Vencut(LocalDate.of(2026, 8, 3), 2, 0.0),
        new EstatPrestec.Vencut(LocalDate.of(2026, 5, 22), 75, 18.25),
        new EstatPrestec.Retornat(LocalDate.of(2026, 8, 1), true),
        new EstatPrestec.Perdut(LocalDate.of(2026, 7, 15), 42.50));

DescriptorEstat descriptor = new DescriptorEstat();

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

  [100] PERDUT des del 15 de juliol -- reposicio: 42,50 €
  [ 90] VENCUT fa 75 dies -- multa acumulada: 18,25 €
  [ 50] Vencut fa 2 dies (encara en periode de cortesia)
  [ 10] Actiu, venc el 26 de agost
  [  0] Retornat el 1 de agost puntualment

// Crear ne un de solt
Thread virtual = Thread.ofVirtual().name("worker-1").start(() -> {
    System.out.println("Soc un fil virtual: " + Thread.currentThread());
});
virtual.join();

// Sense arrencar
Thread senseArrencar = Thread.ofVirtual().unstarted(tasca);

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

// EL MES IMPORTANT: executor amb un fil virtual PER TASCA
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    for (int i = 0; i < 10_000; i++) {
        executor.submit(() -> {
            Thread.sleep(Duration.ofSeconds(1));
            return "llest";
        });
    }
}   // close() espera que acabin totes: l executor es AutoCloseable

package com.nexussoftware.bibliotech;

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

public class DemostracioFilsVirtuals {

    private static final int TASQUES = 10_000;

    public static void main(String[] args) throws Exception {
        System.out.println("Tasques: " + TASQUES + ", cadascuna bloquejada 1 segon");
        System.out.println("Nuclis: " + Runtime.getRuntime().availableProcessors());
        System.out.println();

        mesurar("Pool de plataforma (200 fils)",
                Executors.newFixedThreadPool(200));

        mesurar("Un fil VIRTUAL per tasca    ",
                Executors.newVirtualThreadPerTaskExecutor());

        // I aixo NO es pot fer amb fils de plataforma
        System.out.println();
        System.out.println("--- 1.000.000 de fils virtuals ---");
        long inici = 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 milio de tasques en %d ms%n",
                System.currentTimeMillis() - inici);
    }

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

Tasques: 10000, cadascuna bloquejada 1 segon
Nuclis: 8

Pool de plataforma (200 fils) ->  50238 ms
Un fil VIRTUAL per tasca      ->   1104 ms

--- 1.000.000 de fils virtuals ---
Un milio de tasques en 2871 ms

// MALAMENT: contradiu el proposit
ExecutorService malament = Executors.newFixedThreadPool(200, Thread.ofVirtual().factory());

// BE: un per tasca
ExecutorService be = Executors.newVirtualThreadPerTaskExecutor();

Semaphore limit = new Semaphore(50);

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

package com.nexussoftware.bibliotech.xarxa;

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

/**
 * VERSIO DEL MODUL 9: pool acotat.
 *
 * El pool limita a 50 clients simultanis. Amb 51 connexions,
 * la 51 espera a la cua; si la cua s omple, es REBUTJA.
 * I no es pot pujar gaire: cada fil son ~1 MB de pila.
 */
public class ServidorCatalegAmbPool {

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

    private static final int PORT = 9090;
    private static final int MAX_CLIENTS = 50;       // <-- el limit
    private static final int CUA = 100;

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

    private volatile boolean actiu = true;

    public void arrencar() throws IOException {
        try (ServerSocket servidor = new ServerSocket(PORT)) {
            servidor.setSoTimeout(1000);
            LOG.info("Servidor al port " + PORT + " (max. " + MAX_CLIENTS + " clients)");

            while (actiu) {
                try {
                    Socket client = servidor.accept();
                    pool.submit(() -> atendre(client));
                } catch (SocketTimeoutException e) {
                    // cicle de comprovacio d 'actiu'
                }
            }
        } finally {
            pool.shutdown();
        }
    }

    private void atendre(Socket client) { /* protocol BTCP/1 */ }
}

package com.nexussoftware.bibliotech.xarxa;

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;

/**
 * VERSIO AMB FILS VIRTUALS.
 *
 * Un fil virtual per connexio, sense pool i sense limit artificial.
 * El codi d atendre() es SEQUENCIAL i BLOQUEJANT, que es com
 * cal escriure l, i tot i aixi escala a desenes de milers de clients.
 */
public class ServidorCataleg implements AutoCloseable {

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

    private static final int PORT = 9090;
    private static final Duration INACTIVITAT = Duration.ofSeconds(30);
    private static final int MAX_LINIA = 4096;

    /**
     * Un fil VIRTUAL per tasca. Ja no hi ha mida de pool a ajustar,
     * ni cua, ni politica de rebuig.
     */
    private final ExecutorService atenedors = Executors.newVirtualThreadPerTaskExecutor();

    private final AtomicLong connexionsTotals = new AtomicLong();
    private final AtomicLong connexionsActives = new AtomicLong();

    private volatile boolean actiu = true;
    private ServerSocket servidor;

    public void arrencar() throws IOException {
        servidor = new ServerSocket(PORT);
        servidor.setSoTimeout(1000);

        LOG.info(() -> "ServidorCataleg escoltant al port " + PORT
                + " (un fil virtual per connexio, sense limit de pool)");

        // Fil virtual dedicat a informar de l estat
        Thread.ofVirtual().name("monitor").start(this::monitoritzar);

        while (actiu) {
            try {
                Socket client = servidor.accept();

                // Un fil virtual PER CONNEXIO. Crear lo costa microsegons.
                atenedors.submit(() -> atendre(client));

            } catch (SocketTimeoutException e) {
                // cicle normal
            } catch (IOException e) {
                if (actiu) {
                    LOG.log(Level.WARNING, "Error en acceptar la connexio", e);
                }
            }
        }
    }

    /**
     * Codi SEQUENCIAL i BLOQUEJANT: exactament el mateix de 09-03.
     * readLine() bloqueja, i no passa res: el fil virtual es desmunta.
     */
    private void atendre(Socket client) {
        long numero = connexionsTotals.incrementAndGet();
        connexionsActives.incrementAndGet();

        // Anomenar el fil fa llegibles les traces i els bolcats
        Thread.currentThread().setName("client-" + numero);

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

            client.setSoTimeout((int) INACTIVITAT.toMillis());

            sortida.println("BTCP/1 BENVINGUT BiblioTech");

            String linia;
            while ((linia = llegirLiniaAcotada(entrada)) != null) {

                String resposta = switch (linia.split(" ", 2)[0].toUpperCase()) {
                    case "CERCAR"  -> cercar(linia);
                    case "PRESTAR" -> prestar(linia);
                    case "ESTAT"   -> "OK ACTIVES=" + connexionsActives.get()
                                      + " TOTALS=" + connexionsTotals.get();
                    case "ADEU"    -> "OK FINS_AVIAT";
                    default        -> "ERROR ORDRE_DESCONEGUDA";
                };

                sortida.println(resposta);

                if (resposta.startsWith("OK FINS_AVIAT")) {
                    break;
                }
            }

        } catch (SocketTimeoutException e) {
            LOG.fine(() -> "Client " + numero + " expulsat per inactivitat");
        } catch (IOException e) {
            LOG.log(Level.FINE, e, () -> "Error amb el client " + numero);
        } finally {
            connexionsActives.decrementAndGet();
        }
    }

    private String llegirLiniaAcotada(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_LINIA) {
                throw new IOException("Linia massa llarga: possible atac");
            }
            sb.append((char) c);
        }
        return sb.isEmpty() ? null : sb.toString().strip();
    }

    private void monitoritzar() {
        while (actiu) {
            try {
                Thread.sleep(Duration.ofSeconds(10));
                LOG.info(() -> String.format("Connexions: %d actives, %d totals",
                        connexionsActives.get(), connexionsTotals.get()));
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                return;
            }
        }
    }

    private String cercar(String ordre)  { return "OK ..."; }
    private String prestar(String ordre) { return "OK ..."; }

    @Override
    public void close() throws IOException {
        actiu = false;
        if (servidor != null) {
            servidor.close();
        }
        atenedors.close();         // espera que acabin els clients en curs
        LOG.info("Servidor aturat");
    }

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

// PROBLEMA: bloqueig dins de synchronized
public class CacheProblematica {

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

    public synchronized Fitxa obtenir(String isbn) {    // synchronized
        return cache.computeIfAbsent(isbn, clau -> {
            return clientMetadades.consultar(clau);     // BLOQUEJA en xarxa -> PINNING
        });
    }
}

// SOLUCIO: ReentrantLock, que SI permet desmuntar
public class CacheCorrecta {

    private final Map<String, Fitxa> cache = new ConcurrentHashMap<>();
    private final ReentrantLock pany = new ReentrantLock();

    public Fitxa obtenir(String isbn) {
        Fitxa existent = cache.get(isbn);
        if (existent != null) {
            return existent;
        }

        pany.lock();                        // ReentrantLock (08-04): sense pinning
        try {
            return cache.computeIfAbsent(isbn, clientMetadades::consultar);
        } finally {
            pany.unlock();
        }
    }
}

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

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

// INUTIL: la tasca no es bloqueja mai
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    for (int i = 0; i < 10_000; i++) {
        executor.submit(() -> calcularHashCostos(dades));    // pur CPU
    }
}

// Amb StructuredTaskScope: l ambit CONTE les subtasques
try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {

    Subtask<Fitxa> fitxa = scope.fork(() -> clientMetadades.consultar(isbn));
    Subtask<byte[]> portada = scope.fork(() -> clientPortades.descarregar(isbn));
    Subtask<List<String>> ressenyes = scope.fork(() -> clientRessenyes.cercar(isbn));

    scope.join();                  // espera les tres
    scope.throwIfFailed();         // si alguna ha fallat, llanca i CANCELLA les altres

    return new FitxaCompleta(fitxa.get(), portada.get(), ressenyes.get());
}   // close() garanteix que cap subtasca no continua viva

public class ContextBiblioTech {

    // Immutable i amb ambit acotat, a diferencia de ThreadLocal
    public static final ScopedValue<String> EMPLEAT = ScopedValue.newInstance();

    public void atendrePeticio(String empleat, Runnable tasca) {
        ScopedValue.where(EMPLEAT, empleat).run(tasca);
        // Fora d aqui, EMPLEAT no esta lligat
    }

    public void enAlgunLlocProfund() {
        if (EMPLEAT.isBound()) {
            LOG.info("Operacio de " + EMPLEAT.get());
        }
    }
}

jshell

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

jshell> cataleg.add("Java Eficac")
$2 ==> true

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

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 d API interna ABANS de tocar res
jdeps --jdk-internals --multi-release 21 bibliotech.jar

# 2. Compilar amb la versio nova pero desti antic
javac --release 11 ...

# 3. Executar amb la JVM nova i el codi antic, veient els avisos
java --illegal-access=warn -jar bibliotech.jar     # fins a Java 16

# 4. Actualitzar dependencies UNA a UNA, no totes de cop

# 5. Pujar el desti de compilacio
javac --release 21 ...

# 6. Modernitzar el codi (opcional i gradual):
#    var, switch d expressio, records, blocs de text, streams

package com.nexussoftware.bibliotech.domini;

import java.util.List;

/**
 * Arrel SEGELLADA del cataleg. Un element es, o un material concret,
 * o una colleccio que agrupa altres elements.
 */
public sealed interface ElementCataleg permits Material, Colleccio {

    String getIsbn();
    String getTitol();
}

package com.nexussoftware.bibliotech.domini;

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

/**
 * Agrupacio d elements. Pot contenir colleccions imbricades:
 * es una estructura recursiva (el patro Composite, formalitzat a 12-02).
 */
public record Colleccio(String isbn, String titol, List<ElementCataleg> elements)
        implements ElementCataleg {

    public Colleccio {
        Objects.requireNonNull(isbn, "isbn");
        Objects.requireNonNull(titol, "titol");
        elements = List.copyOf(elements);        // copia defensiva immutable
    }

    @Override public String getIsbn()  { return isbn; }
    @Override public String getTitol() { return titol; }
}

package com.nexussoftware.bibliotech.domini;

/**
 * Jerarquia de materials, TANCADA a quatre tipus.
 * Cada subclasse declara explicitament si es pot estendre.
 */
public sealed abstract class Material
        implements ElementCataleg
        permits Llibre, Revista, Dvd, AudioLlibre {

    private final String isbn;
    private final String titol;
    private final double valoracio;

    protected Material(String isbn, String titol, double valoracio) {
        this.isbn = isbn;
        this.titol = titol;
        this.valoracio = valoracio;
    }

    @Override public String getIsbn()  { return isbn; }
    @Override public String getTitol() { return titol; }
    public double getValoracio()       { return valoracio; }
}

/** final: tancada del tot. */
public final class Llibre extends Material {
    private final String autor;
    private final int pagines;

    public Llibre(String isbn, String titol, String autor, int pagines, double valoracio) {
        super(isbn, titol, valoracio);
        this.autor = autor;
        this.pagines = pagines;
    }
    public String getAutor() { return autor; }
    public int getPagines()  { return pagines; }
}

/** sealed: la seva propia jerarquia tancada de dues periodicitats. */
public sealed class Revista extends Material
        permits RevistaMensual, RevistaTrimestral {

    private final int numero;

    protected Revista(String isbn, String titol, int numero, double valoracio) {
        super(isbn, titol, valoracio);
        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 titol, int numero,
                          java.time.Month mes, double valoracio) {
        super(isbn, titol, numero, valoracio);
        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 titol, int numero,
                             int trimestre, double valoracio) {
        super(isbn, titol, numero, valoracio);
        this.trimestre = trimestre;
    }
    public int getTrimestre() { return trimestre; }
}

/** final. */
public final class Dvd extends Material {
    private final String director;
    private final int minuts;
    public Dvd(String isbn, String titol, String director, int minuts, double valoracio) {
        super(isbn, titol, valoracio);
        this.director = director;
        this.minuts = minuts;
    }
    public String getDirector() { return director; }
    public int getMinuts()      { return minuts; }
}

/** non-sealed: DELIBERADAMENT oberta a extensio per tercers. */
public non-sealed class AudioLlibre extends Material {
    private final String narrador;
    private final int minuts;
    public AudioLlibre(String isbn, String titol, String narrador, int minuts, double valoracio) {
        super(isbn, titol, valoracio);
        this.narrador = narrador;
        this.minuts = minuts;
    }
    public String getNarrador() { return narrador; }
    public int getMinuts()      { return minuts; }
}

package com.nexussoftware.bibliotech.domini;

import java.util.List;

/** Tipus suma per al resultat d una cerca. */
public sealed interface ResultatCerca {

    record Trobat(Material material) implements ResultatCerca { }

    record NoTrobat(String consulta, List<String> suggeriments) implements ResultatCerca { }

    record Ambigu(String consulta, List<Material> candidats) implements ResultatCerca { }
}

package com.nexussoftware.bibliotech.servei;

import com.nexussoftware.bibliotech.domini.*;

/**
 * Tots els switch son EXHAUSTIUS i sense default.
 * Si s afegeix un cinque material, cap no compila.
 */
public class ServeiCataleg {

    public int diesDeTermini(Material material) {
        return switch (material) {
            case Llibre l when l.getPagines() > 500 -> 30;
            case Llibre l when l.getPagines() > 200 -> 21;
            case Llibre l                           -> 14;
            case RevistaMensual r                   -> 7;
            case RevistaTrimestral r                -> 14;
            case Dvd d when d.getMinuts() > 180     -> 5;
            case Dvd d                              -> 3;
            case AudioLlibre a                      -> 21;
        };
        // Revista es sealed: el compilador accepta cobrir els seus dos subtipus
        // en lloc de Revista, i comprova que hi son tots dos.
    }

    public double valorDeReposicio(Material material) {
        return switch (material) {
            case Llibre l            -> Math.max(15.0, l.getPagines() * 0.08);
            case RevistaMensual r    -> 8.0;
            case RevistaTrimestral r -> 14.0;
            case Dvd d               -> Math.max(10.0, d.getMinuts() * 0.15);
            case AudioLlibre a       -> Math.max(20.0, a.getMinuts() * 0.10);
        };
    }

    public String etiquetaDePrestatge(ElementCataleg element) {
        String prefix = switch (element) {
            case Llibre l            -> "LLI";
            case RevistaMensual r    -> "REM";
            case RevistaTrimestral r -> "RET";
            case Dvd d               -> "DVD";
            case AudioLlibre a       -> "AUD";
            case Colleccio c         -> "COL";
        };
        return prefix + "-" + element.getIsbn().substring(4, 8);
    }

    /** Fitxa amb blocs de text i formatted (Java 15). */
    public String fitxa(ElementCataleg element) {
        return switch (element) {

            case Llibre l -> """
                    ┌─ LLIBRE ────────────────────────────
                    │ %s
                    │ Autor:      %s
                    │ Pagines:    %d
                    │ Prestatge:  %s
                    │ Termini:    %d dies
                    │ Reposicio:  %.2f €
                    └─────────────────────────────────────"""
                    .formatted(l.getTitol(), l.getAutor(), l.getPagines(),
                               etiquetaDePrestatge(l), diesDeTermini(l), valorDeReposicio(l));

            case RevistaMensual r -> """
                    ┌─ REVISTA MENSUAL ───────────────────
                    │ %s num. %d (%s)
                    │ Prestatge:  %s
                    │ Termini:    %d dies
                    └─────────────────────────────────────"""
                    .formatted(r.getTitol(), r.getNumero(), r.getMes(),
                               etiquetaDePrestatge(r), diesDeTermini(r));

            case RevistaTrimestral r -> """
                    ┌─ REVISTA TRIMESTRAL ────────────────
                    │ %s num. %d (T%d)
                    │ Prestatge:  %s
                    │ Termini:    %d dies
                    └─────────────────────────────────────"""
                    .formatted(r.getTitol(), r.getNumero(), r.getTrimestre(),
                               etiquetaDePrestatge(r), diesDeTermini(r));

            case Dvd d -> """
                    ┌─ DVD ───────────────────────────────
                    │ %s
                    │ Director:   %s
                    │ Durada:     %d min
                    │ Termini:    %d dies
                    └─────────────────────────────────────"""
                    .formatted(d.getTitol(), d.getDirector(), d.getMinuts(), diesDeTermini(d));

            case AudioLlibre a -> """
                    ┌─ AUDIOLLIBRE ───────────────────────
                    │ %s
                    │ Narrador:   %s
                    │ Durada:     %d min
                    │ Termini:    %d dies
                    └─────────────────────────────────────"""
                    .formatted(a.getTitol(), a.getNarrador(), a.getMinuts(), diesDeTermini(a));

            case Colleccio(var isbn, var titol, var elements) -> """
                    ┌─ COLLECCIO ─────────────────────────
                    │ %s
                    │ Elements:   %d directes, %d en total
                    │ Prestatge:  %s
                    └─────────────────────────────────────"""
                    .formatted(titol, elements.size(),
                               comptarMaterials(element), etiquetaDePrestatge(element));
        };
    }

    /**
     * RECURSIU amb patro de registre: la colleccio es descompon
     * i es descendeix pels seus elements.
     */
    public int comptarMaterials(ElementCataleg element) {
        return switch (element) {
            case Material m -> 1;
            case Colleccio(var isbn, var titol, var elements) ->
                    elements.stream()
                            .mapToInt(this::comptarMaterials)     // recursio
                            .sum();
        };
    }

    /** Profunditat maxima d imbricacio. */
    public int profunditat(ElementCataleg element) {
        return switch (element) {
            case Material m -> 0;
            case Colleccio(var isbn, var titol, var elements) ->
                    1 + elements.stream()
                                .mapToInt(this::profunditat)
                                .max().orElse(0);
        };
    }

    /** El resultat de cerca, tambe amb switch exhaustiu. */
    public String descriureCerca(ResultatCerca resultat) {
        return switch (resultat) {

            case ResultatCerca.Trobat(Material m) ->
                    "Trobat: " + m.getTitol();

            case ResultatCerca.NoTrobat(var consulta, var suggeriments)
                    when suggeriments.isEmpty() ->
                    "No hi ha resultats per a \"" + consulta + "\"";

            case ResultatCerca.NoTrobat(var consulta, var suggeriments) ->
                    "No hi ha resultats per a \"" + consulta + "\". Potser: "
                    + String.join(", ", suggeriments) + "?";

            case ResultatCerca.Ambigu(var consulta, var candidats) ->
                    candidats.size() + " coincidencies per a \"" + consulta + "\": "
                    + candidats.stream().map(Material::getTitol)
                               .collect(java.util.stream.Collectors.joining(", "));
        };
    }
}

package com.nexussoftware.bibliotech;

import com.nexussoftware.bibliotech.domini.*;
import com.nexussoftware.bibliotech.servei.ServeiCataleg;

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

public class ProvaCatalegSegellat {

    public static void main(String[] args) {

        ServeiCataleg servei = new ServeiCataleg();

        Llibre eficac = new Llibre("978-0000000001", "Java Eficac", "Joshua Bloch", 412, 4.85);
        Llibre patrons = new Llibre("978-0000000002", "Patrons de Disseny", "GoF", 395, 4.60);
        Llibre refactor = new Llibre("978-0000000003", "Refactoritzacio", "M. Fowler", 448, 4.72);
        RevistaMensual javaMag = new RevistaMensual("978-0000000010", "Java Magazine",
                                                    142, Month.AUGUST, 3.90);
        Dvd cursSpring = new Dvd("978-0000000020", "Curs de Spring", "N. Vidal", 240, 4.10);
        AudioLlibre audio = new AudioLlibre("978-0000000030", "Codi Net (audio)",
                                            "D. Alonso", 480, 4.30);

        // Colleccio IMBRICADA
        Colleccio essencials = new Colleccio("978-1000000001", "Essencials de Java",
                List.of(eficac, patrons, refactor));

        Colleccio multimedia = new Colleccio("978-1000000002", "Formacio multimedia",
                List.of(cursSpring, audio));

        Colleccio completa = new Colleccio("978-1000000000", "Biblioteca tecnica Nexus",
                List.of(essencials, multimedia, javaMag));

        System.out.println(servei.fitxa(eficac));
        System.out.println(servei.fitxa(javaMag));
        System.out.println(servei.fitxa(audio));
        System.out.println(servei.fitxa(completa));

        System.out.println();
        System.out.println("Materials totals: " + servei.comptarMaterials(completa));
        System.out.println("Profunditat:      " + servei.profunditat(completa));

        System.out.println();
        System.out.println(servei.descriureCerca(
                new ResultatCerca.Trobat(eficac)));
        System.out.println(servei.descriureCerca(
                new ResultatCerca.NoTrobat("kotlin", List.of())));
        System.out.println(servei.descriureCerca(
                new ResultatCerca.NoTrobat("javaa", List.of("Java Eficac"))));
        System.out.println(servei.descriureCerca(
                new ResultatCerca.Ambigu("java", List.of(eficac, audio))));
    }
}

┌─ LLIBRE ────────────────────────────
│ Java Eficac
│ Autor:      Joshua Bloch
│ Pagines:    412
│ Prestatge:  LLI-0000
│ Termini:    21 dies
│ Reposicio:  32,96 €
└─────────────────────────────────────
┌─ REVISTA MENSUAL ───────────────────
│ Java Magazine num. 142 (AUGUST)
│ Prestatge:  REM-0000
│ Termini:    7 dies
└─────────────────────────────────────
┌─ AUDIOLLIBRE ───────────────────────
│ Codi Net (audio)
│ Narrador:   D. Alonso
│ Durada:     480 min
│ Termini:    21 dies
└─────────────────────────────────────
┌─ COLLECCIO ─────────────────────────
│ Biblioteca tecnica Nexus
│ Elements:   3 directes, 6 en total
│ Prestatge:  COL-1000
└─────────────────────────────────────

Materials totals: 6
Profunditat:      2

Trobat: Java Eficac
No hi ha resultats per a "kotlin"
No hi ha resultats per a "javaa". Potser: Java Eficac?
2 coincidencies per a "java": Java Eficac, Codi Net (audio)

public sealed abstract class Material
        implements ElementCataleg
        permits Llibre, Revista, Dvd, AudioLlibre, Mapa { }

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

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

package com.nexussoftware.bibliotech.xarxa;

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

/**
 * Enriquidor de cataleg amb FILS VIRTUALS.
 * Substitueix la versio de 09-06 basada en CompletableFuture.
 */
public class EnriquidorVirtual implements AutoCloseable {

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

    /** Tipus suma per al resultat de cada ISBN. */
    public sealed interface ResultatEnriquiment {
        String isbn();

        record Complet(String isbn, String metadades, int bytesPortada, long ms)
                implements ResultatEnriquiment { }

        record Parcial(String isbn, String metadades, String motiuSensePortada, long ms)
                implements ResultatEnriquiment { }

        record Fallit(String isbn, String motiu, long ms)
                implements ResultatEnriquiment { }
    }

    /**
     * Semafor, NO mida de pool: la restriccio es del servei
     * extern, no dels nostres fils.
     */
    private final Semaphore limitExtern;

    private final ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();

    private final ClientMetadades metadades;
    private final ClientPortades portades;

    public EnriquidorVirtual(ClientMetadades metadades, ClientPortades portades,
                             int peticionsSimultanies) {
        this.metadades = metadades;
        this.portades = portades;
        this.limitExtern = new Semaphore(peticionsSimultanies);
    }

    public List<ResultatEnriquiment> enriquir(List<String> isbns) {

        List<Future<ResultatEnriquiment>> futurs = new ArrayList<>(isbns.size());

        // Es llancen TOTES: un fil virtual per ISBN, siguin 100 o 100.000
        for (String isbn : isbns) {
            futurs.add(executor.submit(() -> processarUn(isbn)));
        }

        List<ResultatEnriquiment> resultats = new ArrayList<>(isbns.size());
        for (int i = 0; i < futurs.size(); i++) {
            try {
                resultats.add(futurs.get(i).get());
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                break;
            } catch (ExecutionException e) {
                resultats.add(new ResultatEnriquiment.Fallit(
                        isbns.get(i), "excepcio no controlada: " + e.getCause(), 0));
            }
        }
        return resultats;
    }

    /**
     * CODI SEQUENCIAL I BLOQUEJANT. Ni un thenCompose, ni un
     * thenCombine, ni una retrucada. Es llegeix de dalt a baix.
     */
    private ResultatEnriquiment processarUn(String isbn) {

        long inici = System.nanoTime();
        Thread.currentThread().setName("enriquir-" + isbn);

        try {
            // 1. Metadades: bloqueja, i no passa res
            String dades;
            limitExtern.acquire();
            try {
                dades = metadades.consultar(isbn);       // crida BLOQUEJANT
            } finally {
                limitExtern.release();
            }

            // 2. Portada: pot fallar sense invalidar el resultat
            int bytes;
            try {
                limitExtern.acquire();
                try {
                    bytes = portades.descarregar(isbn).length;
                } finally {
                    limitExtern.release();
                }
            } catch (Exception e) {
                return new ResultatEnriquiment.Parcial(
                        isbn, dades, e.getClass().getSimpleName(), ms(inici));
            }

            return new ResultatEnriquiment.Complet(isbn, dades, bytes, ms(inici));

        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return new ResultatEnriquiment.Fallit(isbn, "interromput", ms(inici));

        } catch (Exception e) {
            LOG.log(Level.FINE, e, () -> "Fallada en enriquir " + isbn);
            return new ResultatEnriquiment.Fallit(
                    isbn, e.getClass().getSimpleName() + ": " + e.getMessage(), ms(inici));
        }
    }

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

    /** Informe amb switch exhaustiu sobre el tipus segellat. */
    public String informar(List<ResultatEnriquiment> resultats) {

        Map<String, Long> perTipus = resultats.stream()
                .collect(java.util.stream.Collectors.groupingBy(
                        r -> switch (r) {
                            case ResultatEnriquiment.Complet c -> "complets";
                            case ResultatEnriquiment.Parcial p -> "parcials";
                            case ResultatEnriquiment.Fallit f  -> "fallits";
                        },
                        java.util.TreeMap::new,
                        java.util.stream.Collectors.counting()));

        double mitjanaMs = resultats.stream()
                .mapToLong(r -> switch (r) {
                    case ResultatEnriquiment.Complet c -> c.ms();
                    case ResultatEnriquiment.Parcial p -> p.ms();
                    case ResultatEnriquiment.Fallit f  -> f.ms();
                })
                .average().orElse(0);

        return """
                Enriquiment de %d ISBN
                  %s
                  Durada mitjana per ISBN: %.1f ms"""
                .formatted(resultats.size(), perTipus, mitjanaMs);
    }

    @Override
    public void close() {
        executor.close();        // ExecutorService es AutoCloseable des de 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 ComparativaEnriquiment {

    /** Simula una crida de xarxa: 50 ms d espera. */
    private static String consultarSimulat(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)", "VIRTUALS", "COMPL.FUTURE");
        System.out.println("-".repeat(56));

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

            long plataforma = mesurar(() -> ambPoolDePlataforma(isbns));
            long virtuals   = mesurar(() -> ambFilsVirtuals(isbns));
            long futurs     = mesurar(() -> ambCompletableFuture(isbns));

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

        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 mesurar(Runnable tasca) {
        long inici = System.currentTimeMillis();
        tasca.run();
        return System.currentTimeMillis() - inici;
    }

    private static void ambPoolDePlataforma(List<String> isbns) {
        try (var executor = Executors.newFixedThreadPool(200)) {
            List<Future<String>> futurs = isbns.stream()
                    .map(isbn -> executor.submit(() -> consultarSimulat(isbn)))
                    .toList();
            futurs.forEach(ComparativaEnriquiment::obtenir);
        }
    }

    private static void ambFilsVirtuals(List<String> isbns) {
        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            List<Future<String>> futurs = isbns.stream()
                    .map(isbn -> executor.submit(() -> consultarSimulat(isbn)))
                    .toList();
            futurs.forEach(ComparativaEnriquiment::obtenir);
        }
    }

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

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

    // ------------------------------------------------------------------
    // Demostracio del PINNING
    // ------------------------------------------------------------------

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

        /** synchronized + bloqueig -> PINNING del fil portador. */
        public synchronized String obtenir(String isbn) throws InterruptedException {
            String v = cache.get(isbn);
            if (v == null) {
                v = consultarSimulat(isbn);
                cache.put(isbn, v);
            }
            return v;
        }
    }

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

        /** ReentrantLock permet desmuntar el fil virtual. */
        public String obtenir(String isbn) throws InterruptedException {
            String v = cache.get(isbn);
            if (v != null) {
                return v;
            }
            pany.lock();
            try {
                v = cache.get(isbn);
                if (v == null) {
                    v = consultarSimulat(isbn);
                    cache.put(isbn, v);
                }
                return v;
            } finally {
                pany.unlock();
            }
        }
    }

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

        AmbSynchronized ambSync = new AmbSynchronized();
        long t1 = mesurar(() -> {
            try (var e = Executors.newVirtualThreadPerTaskExecutor()) {
                isbns.forEach(isbn -> e.submit(() -> ambSync.obtenir(isbn)));
            }
        });

        AmbReentrantLock ambPany = new AmbReentrantLock();
        long t2 = mesurar(() -> {
            try (var e = Executors.newVirtualThreadPerTaskExecutor()) {
                isbns.forEach(isbn -> e.submit(() -> ambPany.obtenir(isbn)));
            }
        });

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

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

--- Pinning (executar amb -Djdk.tracePinnedThreads=full) ---
  synchronized:  25142 ms
  ReentrantLock: 25089 ms

package com.nexussoftware.bibliotech.eines;

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 oportunitats de modernitzacio en codi Java.
 *
 * Es una analisi per expressions regulars: rapida i aproximada.
 * Un analitzador real treballaria sobre l AST (javax.lang.model, 10-02).
 */
public class AnalitzadorDeModernitzacio {

    /** Tipus segellat per a les categories de troballa. */
    public sealed interface Troballa {
        Path fitxer();
        int linia();
        int versioJava();
        String suggeriment();

        record ConcatenacioMultilinia(Path fitxer, int linia) implements Troballa {
            public int versioJava() { return 15; }
            public String suggeriment() { return "Fes servir un bloc de text \"\"\"...\"\"\""; }
        }
        record SwitchClassic(Path fitxer, int linia) implements Troballa {
            public int versioJava() { return 14; }
            public String suggeriment() { return "Fes servir switch d expressio amb ->"; }
        }
        record CastDespresInstanceof(Path fitxer, int linia, String tipus) implements Troballa {
            public int versioJava() { return 16; }
            public String suggeriment() { return "Fes servir instanceof " + tipus + " variable"; }
        }
        record ApiDeDatesAntiga(Path fitxer, int linia, String classe) implements Troballa {
            public int versioJava() { return 8; }
            public String suggeriment() {
                return switch (classe) {
                    case "SimpleDateFormat" -> "Fes servir DateTimeFormatter (immutable i segur entre fils)";
                    case "Calendar"         -> "Fes servir LocalDate / LocalDateTime";
                    case "Date"             -> "Fes servir Instant o LocalDate segons el cas";
                    default                 -> "Migra a java.time";
                };
            }
        }
        record PoolDePlataforma(Path fitxer, int linia) implements Troballa {
            public int versioJava() { return 21; }
            public String suggeriment() {
                return "Si les tasques es bloquegen, fes servir Executors.newVirtualThreadPerTaskExecutor()";
            }
        }
        record BucleAcumulador(Path fitxer, int linia) implements Troballa {
            public int versioJava() { return 8; }
            public String suggeriment() { return "Considera stream().filter(...).map(...).toList()"; }
        }
        record CandidatARecord(Path fitxer, int linia, String classe) implements Troballa {
            public int versioJava() { return 16; }
            public String suggeriment() { return "La classe " + classe + " podria ser un record"; }
        }
    }

    // --- Patrons ---
    private static final Pattern CONCATENACIO = Pattern.compile("^\\s*\\+\\s*\"");
    private static final Pattern SWITCH_CLASSIC = Pattern.compile("\\bcase\\s+[^>]+:\\s*$");
    private static final Pattern INSTANCEOF_SENSE_PATRO =
            Pattern.compile("instanceof\\s+(\\w+)\\s*\\)\\s*\\{?\\s*$");
    private static final Pattern CAST = Pattern.compile("\\(\\s*(\\w+)\\s*\\)\\s*\\w+");
    private static final Pattern DATES_ANTIGUES =
            Pattern.compile("\\bnew\\s+(SimpleDateFormat|Date|GregorianCalendar)\\b"
                          + "|\\bCalendar\\.getInstance\\(\\)");
    private static final Pattern POOL_FIX =
            Pattern.compile("Executors\\.newFixedThreadPool|Executors\\.newCachedThreadPool");
    private static final Pattern DECLARACIO_LLISTA =
            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<Troballa> analitzar(Path arrel) throws IOException {
        try (Stream<Path> fitxers = Files.walk(arrel)) {
            return fitxers
                    .filter(Files::isRegularFile)
                    .filter(p -> p.toString().endsWith(".java"))
                    .filter(p -> !p.getFileName().toString().equals("module-info.java"))
                    .flatMap(this::analitzarFitxer)
                    .toList();
        }
    }

    private Stream<Troballa> analitzarFitxer(Path fitxer) {
        try {
            List<String> linies = Files.readAllLines(fitxer, StandardCharsets.UTF_8);
            List<Troballa> troballes = new ArrayList<>();

            String possibleTipusInstanceof = null;
            int liniaInstanceof = 0;
            int liniesDeDeclaracio = 0;
            int iniciDeclaracio = 0;

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

                if (CONCATENACIO.matcher(linia).find()) {
                    troballes.add(new Troballa.ConcatenacioMultilinia(fitxer, numero));
                }
                if (SWITCH_CLASSIC.matcher(linia).find()) {
                    troballes.add(new Troballa.SwitchClassic(fitxer, numero));
                }
                if (DATES_ANTIGUES.matcher(linia).find()) {
                    var m = DATES_ANTIGUES.matcher(linia);
                    m.find();
                    String classe = m.group(1) != null ? m.group(1) : "Calendar";
                    troballes.add(new Troballa.ApiDeDatesAntiga(fitxer, numero, classe));
                }
                if (POOL_FIX.matcher(linia).find()) {
                    troballes.add(new Troballa.PoolDePlataforma(fitxer, numero));
                }

                // instanceof en una linia, conversio al mateix tipus a la seguent
                var mi = INSTANCEOF_SENSE_PATRO.matcher(linia);
                if (mi.find()) {
                    possibleTipusInstanceof = mi.group(1);
                    liniaInstanceof = numero;
                } else if (possibleTipusInstanceof != null) {
                    var mc = CAST.matcher(linia);
                    if (mc.find() && possibleTipusInstanceof.equals(mc.group(1))) {
                        troballes.add(new Troballa.CastDespresInstanceof(
                                fitxer, liniaInstanceof, possibleTipusInstanceof));
                    }
                    possibleTipusInstanceof = null;
                }

                // Declaracio de colleccio seguida de bucle for-each: candidat a stream
                if (DECLARACIO_LLISTA.matcher(linia).find()) {
                    liniesDeDeclaracio = 1;
                    iniciDeclaracio = numero;
                } else if (liniesDeDeclaracio > 0 && liniesDeDeclaracio < 4) {
                    if (FOR_EACH.matcher(linia).find()) {
                        troballes.add(new Troballa.BucleAcumulador(fitxer, iniciDeclaracio));
                        liniesDeDeclaracio = 0;
                    } else {
                        liniesDeDeclaracio++;
                    }
                } else {
                    liniesDeDeclaracio = 0;
                }
            }

            detectarCandidatARecord(fitxer, linies).ifPresent(troballes::add);
            return troballes.stream();

        } catch (IOException e) {
            System.err.println("No s ha pogut llegir " + fitxer + ": " + e.getMessage());
            return Stream.empty();
        }
    }

    /** Heuristica: nomes camps final, getters, equals, hashCode i toString. */
    private Optional<Troballa> detectarCandidatARecord(Path fitxer, List<String> linies) {
        String contingut = String.join("\n", linies);

        boolean teSetters = contingut.contains("public void set");
        boolean teCampsNoFinals = Pattern
                .compile("private\\s+(?!final)\\w+\\s+\\w+\\s*;").matcher(contingut).find();
        boolean teEquals = contingut.contains("public boolean equals(Object");
        boolean teHashCode = contingut.contains("public int hashCode()");
        boolean hereta = Pattern.compile("class\\s+\\w+\\s+extends").matcher(contingut).find();

        if (!teSetters && !teCampsNoFinals && teEquals && teHashCode && !hereta) {
            String nom = fitxer.getFileName().toString().replace(".java", "");
            int linia = 1 + (int) linies.stream()
                    .takeWhile(l -> !l.contains("class " + nom))
                    .count();
            return Optional.of(new Troballa.CandidatARecord(fitxer, linia, nom));
        }
        return Optional.empty();
    }

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

    public String informar(List<Troballa> troballes, int versioObjectiu) {

        Map<String, List<Troballa>> perTipus = troballes.stream()
                .collect(Collectors.groupingBy(h -> h.getClass().getSimpleName(),
                         TreeMap::new, Collectors.toList()));

        Map<Integer, Long> perVersio = troballes.stream()
                .collect(Collectors.groupingBy(Troballa::versioJava,
                         TreeMap::new, Collectors.counting()));

        long aplicables = troballes.stream()
                .filter(h -> h.versioJava() <= versioObjectiu)
                .count();

        StringBuilder sb = new StringBuilder();
        sb.append("""
                ════════════════════════════════════════════════════
                  INFORME DE MODERNITZACIO -- objectiu: Java %d
                ════════════════════════════════════════════════════
                  Troballes totals:      %d
                  Aplicables ja:         %d
                  Requereixen migrar:    %d
                """.formatted(versioObjectiu, troballes.size(),
                              aplicables, troballes.size() - aplicables));

        sb.append("\nPER VERSIO MINIMA NECESSARIA\n");
        perVersio.forEach((v, n) -> sb.append(String.format(
                "  Java %-3d %4d  %s%s%n", v, n, "▇".repeat((int) Math.min(n, 40)),
                v <= versioObjectiu ? "" : "   (requereix migrar)")));

        sb.append("\nPER TIPUS\n");
        perTipus.forEach((tipus, llista) -> {
            sb.append(String.format("  %-26s %4d%n", tipus, llista.size()));
            llista.stream().limit(3).forEach(h -> sb.append(String.format(
                    "      %s:%d  %s%n",
                    h.fitxer().getFileName(), h.linia(), h.suggeriment())));
            if (llista.size() > 3) {
                sb.append(String.format("      ... i %d mes%n", llista.size() - 3));
            }
        });

        return sb.toString();
    }

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

        AnalitzadorDeModernitzacio analitzador = new AnalitzadorDeModernitzacio();
        List<Troballa> troballes = analitzador.analitzar(arrel);

        System.out.println(analitzador.informar(troballes, objectiu));
    }
}

════════════════════════════════════════════════════
  INFORME DE MODERNITZACIO -- objectiu: Java 21
════════════════════════════════════════════════════
  Troballes totals:      47
  Aplicables ja:         47
  Requereixen migrar:    0

PER VERSIO MINIMA NECESSARIA
  Java 8     14  ▇▇▇▇▇▇▇▇▇▇▇▇▇▇
  Java 14     9  ▇▇▇▇▇▇▇▇▇
  Java 15    11  ▇▇▇▇▇▇▇▇▇▇▇
  Java 16     8  ▇▇▇▇▇▇▇▇
  Java 21     5  ▇▇▇▇▇

PER TIPUS
  ApiDeDatesAntiga            9
      GestorSessio.java:34  Fes servir DateTimeFormatter (immutable i segur entre fils)
      MagatzemPrestecs.java:57  Fes servir LocalDate / LocalDateTime
      RegistreOperacions.java:22  Fes servir Instant o LocalDate segons el cas
      ... i 6 mes
  BucleAcumulador             5
      EstadistiquesBiblioTech.java:19  Considera stream().filter(...).map(...).toList()
      MenuBiblioTech.java:88  Considera stream().filter(...).map(...).toList()
      ... i 3 mes
  CandidatARecord             3
      Fitxa.java:8  La classe Fitxa podria ser un record
      ResumSessio.java:11  La classe ResumSessio podria ser un record
      ... i 1 mes
  CastDespresInstanceof       8
      CalculadoraTerminisAntiga.java:14  Fes servir instanceof Llibre variable
      ExportadorCatalegCsv.java:41  Fes servir instanceof Material variable
      ... i 6 mes
  ConcatenacioMultilinia     11
      ConsultesBiblioTech.java:12  Fes servir un bloc de text """..."""
      ClientMetadades.java:73  Fes servir un bloc de text """..."""
      ... i 9 mes
  PoolDePlataforma            5
      ServidorCatalegAmbPool.java:24  Si les tasques es bloquegen, fes servir Executors.newVirtualThreadPerTaskExecutor()
      ... i 4 mes
  SwitchClassic               6
      MenuBiblioTech.java:52  Fes servir switch d expressio amb ->
      ... i 5 mes