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

public class CatalegAntic {

    public static void main(String[] args) {
        List cataleg = new ArrayList();   // sense generics: guarda Object

        cataleg.add(new Llibre("Java Eficac", "978-0000000001"));
        cataleg.add(new Llibre("Patrons de Disseny", "978-0000000002"));
        cataleg.add("Refactoritzacio");   // ERROR! pero el compilador calla

        for (int i = 0; i < cataleg.size(); i++) {
            Llibre llibre = (Llibre) cataleg.get(i);   // conversio obligatoria
            System.out.println(llibre.getTitol());
        }
    }
}

Java Eficac
Patrons de Disseny
Exception in thread "main" java.lang.ClassCastException:
    class java.lang.String cannot be cast to class Llibre
    at CatalegAntic.main(CatalegAntic.java:14)

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

public class CatalegModern {

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

        cataleg.add(new Llibre("Java Eficac", "978-0000000001"));
        cataleg.add(new Llibre("Patrons de Disseny", "978-0000000002"));
        // cataleg.add("Refactoritzacio");   // NO COMPILA

        for (Llibre llibre : cataleg) {       // sense conversio
            System.out.println(llibre.getTitol());
        }
    }
}

error: no suitable method found for add(String)
    cataleg.add("Refactoritzacio");
           ^
    method Collection.add(Llibre) is not applicable
      (argument mismatch; String cannot be converted to Llibre)

package com.nexussoftware.bibliotech.domini;

/**
 * Contenidor d'un unic valor de tipus T.
 * T es un PARAMETRE DE TIPUS: no existeix fins que algu
 * escriu Capsa<Llibre> o Capsa<String>.
 */
public class Capsa<T> {

    private T contingut;          // camp del tipus parametritzat

    public Capsa(T contingut) {   // parametre del tipus parametritzat
        this.contingut = contingut;
    }

    public T obtenir() {          // retorn del tipus parametritzat
        return contingut;
    }

    public void desar(T contingut) {
        this.contingut = contingut;
    }

    public boolean estaBuida() {
        return contingut == null;
    }

    @Override
    public String toString() {
        return "Capsa[" + contingut + "]";
    }
}

Capsa<Llibre> capsaLlibre = new Capsa<>(new Llibre("Java Eficac", "978-0000000001"));
Llibre l = capsaLlibre.obtenir();   // sense conversio: el compilador sap que es Llibre

Capsa<String> capsaText = new Capsa<>("Sala 3");
String s = capsaText.obtenir();

// capsaLlibre.desar("aixo no");    // NO COMPILA

/**
 * Parell de valors de tipus possiblement diferents.
 * Es, en essencia, el que fa Map.Entry<K, V>.
 */
public class Parell<A, B> {

    private final A primer;
    private final B segon;

    public Parell(A primer, B segon) {
        this.primer = primer;
        this.segon = segon;
    }

    public A primer()  { return primer; }
    public B segon()   { return segon; }

    /** Retorna el parell amb els elements intercanviats. */
    public Parell<B, A> invertir() {
        return new Parell<>(segon, primer);
    }

    @Override
    public String toString() {
        return "(" + primer + ", " + segon + ")";
    }
}

Parell<String, Integer> prestecsPerEmpleat = new Parell<>("Marta Ruiz", 4);
Parell<Integer, String> invertit = prestecsPerEmpleat.invertir();
System.out.println(prestecsPerEmpleat);   // (Marta Ruiz, 4)
System.out.println(invertit);             // (4, Marta Ruiz)

Map<String, List<Prestec>> perEmpleat = new HashMap<String, List<Prestec>>();

Map<String, List<Prestec>> perEmpleat = new HashMap<>();

var cataleg = new ArrayList<Llibre>();    // BE: el tipus va a la dreta
// var llista = new ArrayList<>();        // infereix ArrayList<Object>: gairebe mai es el que vols

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

package com.nexussoftware.bibliotech.domini;

/**
 * Tot el que BiblioTech pot emmagatzemar en un repositori
 * sap dir quin es el seu identificador.
 */
public interface Identificable {
    String getId();
}

package com.nexussoftware.bibliotech.servei;

/**
 * Converteix objectes de tipus T en una linia de text i viceversa.
 * Substitueix els metodes aText/desDeText repetits al modul 7.
 */
public interface Serialitzador<T> {

    String serialitzar(T objecte);

    T deserialitzar(String linia);
}

// FORMA 1: fixar el tipus. La implementacio ja NO es generica.
public class SerialitzadorLlibre implements Serialitzador<Llibre> {

    @Override
    public String serialitzar(Llibre llibre) {
        return llibre.getIsbn() + ";" + llibre.getTitol();
    }

    @Override
    public Llibre deserialitzar(String linia) {
        String[] parts = linia.split(";", 2);
        return new Llibre(parts[1], parts[0]);
    }
}

// FORMA 2: propagar el parametre. La implementacio continua sent generica.
public class SerialitzadorAmbRegistre<T> implements Serialitzador<T> {

    private final Serialitzador<T> delegat;

    public SerialitzadorAmbRegistre(Serialitzador<T> delegat) {
        this.delegat = delegat;
    }

    @Override
    public String serialitzar(T objecte) {
        String resultat = delegat.serialitzar(objecte);
        System.out.println("[SER] " + objecte.getClass().getSimpleName());
        return resultat;
    }

    @Override
    public T deserialitzar(String linia) {
        return delegat.deserialitzar(linia);
    }
}

public class Utilitats {

    /**
     * Intercanvia dues posicions d'una llista de qualsevol tipus.
     *   modificadors  <T>  retorn  nom
     */
    public static <T> void intercanviar(List<T> llista, int i, int j) {
        T temporal = llista.get(i);
        llista.set(i, llista.get(j));
        llista.set(j, temporal);
    }

    /** Retorna el primer element o null si la llista esta buida. */
    public static <T> T primer(List<T> llista) {
        return llista.isEmpty() ? null : llista.get(0);
    }

    /** Construeix una llista a partir d'elements solts. */
    @SafeVarargs
    public static <T> List<T> llistaDe(T... elements) {
        return new ArrayList<>(Arrays.asList(elements));
    }

    /** Compta quants elements de la llista compleixen el predicat. */
    public static <T> long comptar(List<T> llista, Predicate<T> criteri) {
        long total = 0;
        for (T element : llista) {
            if (criteri.test(element)) {
                total++;
            }
        }
        return total;
    }
}

List<Llibre> cataleg = Utilitats.llistaDe(
        new Llibre("Java Eficac", "978-0000000001"),
        new Llibre("Refactoritzacio", "978-0000000003"));

Utilitats.intercanviar(cataleg, 0, 1);        // T s infereix: Llibre
Llibre primer = Utilitats.primer(cataleg);    // T s infereix: Llibre

long prestats = Utilitats.comptar(cataleg, Llibre::estaPrestat);

List<Material> buida = Utilitats.<Material>llistaDe();   // sense arguments no hi ha res a inferir

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

public static <U> Capsa<U> crearBuida() {
    return new Capsa<>(null);
}

/**
 * Retorna l'element mes gran de la llista.
 * T HA DE saber comparar-se amb si mateix.
 */
public static <T extends Comparable<T>> T maxim(List<T> llista) {
    if (llista.isEmpty()) {
        throw new IllegalArgumentException("llista buida");
    }
    T major = llista.get(0);
    for (T element : llista) {
        if (element.compareTo(major) > 0) {   // legal NOMES gracies al limit
            major = element;
        }
    }
    return major;
}

/** Concatena els titols de qualsevol colleccio de materials. */
public static <T extends Material> String titols(List<T> materials) {
    StringBuilder sb = new StringBuilder();
    for (T m : materials) {
        sb.append(m.getTitol()).append("; ");   // getTitol() es de Material
    }
    return sb.toString();
}

/**
 * Ordena i imprimeix elements que a mes de comparables
 * saben serialitzar-se.
 */
public static <T extends Comparable<T> & Serializable> void arxivarOrdenat(List<T> items) {
    Collections.sort(items);
    for (T item : items) {
        System.out.println("Arxivant: " + item);
    }
}

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

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

List<String> textos = new ArrayList<>();
List<Object> objectes = textos;       // suposem que aixo compiles
objectes.add(Integer.valueOf(42));    // legal: un Integer ES un Object
String s = textos.get(0);             // BUM: ClassCastException en execucio

public class CovarianciaArrays {

    public static void main(String[] args) {
        String[] textos = { "Java Eficac", "Refactoritzacio" };
        Object[] objectes = textos;         // COMPILA: els arrays son covariants

        objectes[0] = Integer.valueOf(42);  // compila... i explota en execucio
        System.out.println(textos[0]);
    }
}

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

public static void imprimirTitols(List<Material> materials) {
    for (Material m : materials) {
        System.out.println(m.getTitol());
    }
}

/** Serveix per a QUALSEVOL llista: nomes fa servir metodes que no depenen de T. */
public static void informarMida(List<?> llista) {
    System.out.println("La llista te " + llista.size() + " elements");
    for (Object o : llista) {        // l unic segur es llegir com a Object
        System.out.println("  - " + o);
    }
}

informarMida(List.of("a", "b"));                   // List<String>
informarMida(List.of(new Llibre("Java Eficac", "978-0000000001")));  // List<Llibre>

public static void intentarAfegir(List<?> llista) {
    // llista.add("hola");       // NO COMPILA
    // llista.add(new Object()); // NO COMPILA
    llista.add(null);            // unic permes
}

public static void imprimirTitols(List<? extends Material> materials) {
    for (Material m : materials) {       // llegir com a Material: SEGUR
        System.out.println(m.getTitol());
    }
    // materials.add(new Llibre(...));   // NO COMPILA
}

List<Llibre> llibres = new ArrayList<>();
List<Revista> revistes = new ArrayList<>();
List<Material> barreja = new ArrayList<>();

imprimirTitols(llibres);    // OK
imprimirTitols(revistes);   // OK
imprimirTitols(barreja);    // OK

public static void afegirLlibresDeProva(List<? super Llibre> desti) {
    desti.add(new Llibre("Java Eficac", "978-0000000001"));   // SEGUR
    desti.add(new Llibre("Refactoritzacio", "978-0000000003"));

    // Llibre l = desti.get(0);     // NO COMPILA
    Object o = desti.get(0);        // l unic segur es Object
}

List<Llibre> nomesLlibres = new ArrayList<>();
List<Material> materials = new ArrayList<>();
List<Object> qualsevol = new ArrayList<>();

afegirLlibresDeProva(nomesLlibres);   // OK
afegirLlibresDeProva(materials);      // OK
afegirLlibresDeProva(qualsevol);      // OK

/**
 * Copia elements d'origen a desti.
 *   origen PRODUEIX elements  -> ? extends T
 *   desti  CONSUMEIX elements -> ? super T
 */
public static <T> void copiar(List<? extends T> origen, List<? super T> desti) {
    for (T element : origen) {
        desti.add(element);
    }
}

List<Llibre> llibres = List.of(
        new Llibre("Java Eficac", "978-0000000001"),
        new Llibre("Patrons de Disseny", "978-0000000002"));

List<Material> magatzem = new ArrayList<>();
List<Object> registre   = new ArrayList<>();

Utilitats.<Material>copiar(llibres, magatzem);   // Llibre produeix, Material consumeix
Utilitats.<Llibre>copiar(llibres, registre);     // Llibre produeix, Object consumeix

// MALAMENT: desti declarat com a productor
public static <T> void copiarMalament(List<? extends T> origen, List<? extends T> desti) {
    for (T element : origen) {
        desti.add(element);   // NO COMPILA
    }
}

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

// MALAMENT: origen declarat com a consumidor
public static <T> void copiarMalament2(List<? super T> origen, List<? super T> desti) {
    for (T element : origen) {   // NO COMPILA
        desti.add(element);
    }
}

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

// Collections: origen produeix, desti consumeix
public static <T> void copy(List<? super T> dest, List<? extends T> src)

// El comparador CONSUMEIX elements per comparar-los
public static <T> void sort(List<T> list, Comparator<? super T> c)

// Stream.map: la funcio CONSUMEIX T i PRODUEIX R
<R> Stream<R> map(Function<? super T, ? extends R> mapper)

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

Comparator<Material> perTitol = Comparator.comparing(Material::getTitol);

List<Llibre> llibres = new ArrayList<>(...);
llibres.sort(perTitol);    // funciona gracies al ? super T

public class Capsa<T> {
    private T contingut;
    public T obtenir() { return contingut; }
    public void desar(T c) { this.contingut = c; }
}

public class Capsa {
    private Object contingut;
    public Object obtenir() { return contingut; }
    public void desar(Object c) { this.contingut = c; }
}

Capsa<Llibre> capsa = new Capsa<>(llibre);
Llibre l = capsa.obtenir();

Capsa capsa = new Capsa(llibre);
Llibre l = (Llibre) capsa.obtenir();   // la conversio la posa el compilador

public static <T extends Material> String titols(List<T> llista)
// s esborra a
public static String titols(List llista)   // i a dins, T es tracta com a Material

javac Capsa.java
javap -p Capsa.class

public class Capsa<T> {
  private T contingut;
  public Capsa(T);
  public T obtenir();
  public void desar(T);
}

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

public class Repositori<T> {

    private final Supplier<T> fabrica;

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

    public T crearBuit() {
        return fabrica.get();      // la fabrica SI que sap construir una T
    }
}

// us
Repositori<Llibre> repo = new Repositori<>(Llibre::new);

if (objecte instanceof List<String>) { }   // ERROR: illegal generic type for instanceof
if (objecte instanceof List<?>) { }        // OK: nomes el tipus cru es comprovable

public class Informes {
    // ERROR: name clash: tots dos s esborren a  processar(List)
    public void processar(List<Llibre> llibres) { }
    public void processar(List<Revista> revistes) { }
}

error: name clash: processar(List<Revista>) and processar(List<Llibre>) have the same erasure

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

// SOLUCIO 1 (recomanada): fer servir una List
private final List<T> items = new ArrayList<>();

// SOLUCIO 2: array d Object amb conversio i avis suprimit (el que fa ArrayList per dins)
@SuppressWarnings("unchecked")
private T[] items = (T[]) new Object[10];

List<Llibre> llibres = new ArrayList<>();
List<String> textos = new ArrayList<>();

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

public class ComparadorLlibres implements Comparator<Llibre> {
    @Override
    public int compare(Llibre a, Llibre b) {
        return a.getTitol().compareTo(b.getTitol());
    }
}

// generat pel compilador, marcat com a sintetic i pont
public int compare(Object a, Object b) {
    return compare((Llibre) a, (Llibre) b);   // delega, amb la conversio
}

List cru = new ArrayList();       // tipus cru
cru.add("qualsevol cosa");
cru.add(42);

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

public static void enverinar(List cru) {     // tipus cru
    cru.add("no soc un Llibre");
}

public static void main(String[] args) {
    List<Llibre> cataleg = new ArrayList<>();
    enverinar(cataleg);                      // compila, nomes amb avis

    for (Llibre l : cataleg) {               // ClassCastException aqui
        System.out.println(l.getTitol());
    }
}

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

@SuppressWarnings("unchecked")   // sobre tota la classe: silencia bugs futurs
public class Repositori<T> { ... }

public <T> T[] copiarA(T[] desti) {
    if (desti.length < mida) {
        // SEGUR: Arrays.copyOf amb el tipus real de l array de desti
        // retorna un array del mateix tipus que 'desti', que es T[].
        @SuppressWarnings("unchecked")
        T[] nou = (T[]) Arrays.copyOf(items, mida, desti.getClass());
        return nou;
    }
    System.arraycopy(items, 0, desti, 0, mida);
    return desti;
}

package com.nexussoftware.bibliotech.servei;

import java.lang.reflect.InvocationTargetException;

/**
 * Fabrica generica que SI que pot crear instancies de T,
 * perque rep el Class<T> com a testimoni de tipus.
 */
public class FabricaEntitats<T> {

    private final Class<T> tipus;

    public FabricaEntitats(Class<T> tipus) {
        this.tipus = tipus;
    }

    /** Crea una instancia fent servir el constructor sense arguments. */
    public T crear() {
        try {
            return tipus.getDeclaredConstructor().newInstance();
        } catch (NoSuchMethodException | InstantiationException
                 | IllegalAccessException | InvocationTargetException e) {
            throw new IllegalStateException(
                    "No s ha pogut instanciar " + tipus.getSimpleName(), e);
        }
    }

    /**
     * Converteix amb seguretat: conversio comprovada en EXECUCIO.
     * Si l objecte no es del tipus esperat llanca ClassCastException
     * aqui mateix, no tres capes mes avall.
     */
    public T convertir(Object candidat) {
        return tipus.cast(candidat);
    }

    public String nomTipus() {
        return tipus.getSimpleName();
    }
}

FabricaEntitats<Llibre> fabrica = new FabricaEntitats<>(Llibre.class);
Llibre nou = fabrica.crear();
System.out.println(fabrica.nomTipus());   // Llibre

public class ContextTipat {

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

    public <T> void posar(Class<T> tipus, T valor) {
        valors.put(Objects.requireNonNull(tipus), valor);
    }

    public <T> T obtenir(Class<T> tipus) {
        return tipus.cast(valors.get(tipus));   // conversio segura
    }
}

ContextTipat ctx = new ContextTipat();
ctx.posar(Empleat.class, new Empleat("Marta Ruiz"));
ctx.posar(String.class, "sessio-4711");

Empleat qui = ctx.obtenir(Empleat.class);   // sense conversio, sense avis

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

public <E extends Exception> void executar(Runnable tasca, Class<E> tipus) throws E {
    try {
        tasca.run();
    } catch (Exception e) {
        if (tipus.isInstance(e)) {
            throw tipus.cast(e);     // rellancem ja tipat
        }
        throw new BiblioTechException("Fallada inesperada a la tasca", e);
    }
}

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

/** Executa la tasca propagant la seva excepcio tipada. */
public static <T, E extends Exception> T intentar(SupplierAmbError<T, E> tasca) throws E {
    return tasca.obtenir();
}

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

package com.nexussoftware.bibliotech.servei;

import com.nexussoftware.bibliotech.domini.Identificable;

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

/**
 * Repositori generic i segur entre fils per a qualsevol entitat
 * que sapiga donar el seu identificador.
 *
 * El limit <T extends Identificable> permet cridar getId()
 * dins de la classe sense cap conversio.
 */
public class Repositori<T extends Identificable> {

    private final Map<String, T> perId = new ConcurrentHashMap<>();
    private final String nom;

    public Repositori(String nom) {
        this.nom = Objects.requireNonNull(nom, "nom");
    }

    /** Desa o reemplaca. Retorna el valor anterior, si n hi havia. */
    public Optional<T> desar(T entitat) {
        Objects.requireNonNull(entitat, "entitat");
        return Optional.ofNullable(perId.put(entitat.getId(), entitat));
    }

    /** Desa nomes si no existia. true si s ha inserit. */
    public boolean desarSiAbsent(T entitat) {
        return perId.putIfAbsent(entitat.getId(), entitat) == null;
    }

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

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

    public boolean conte(String id) {
        return perId.containsKey(id);
    }

    public int mida() {
        return perId.size();
    }

    /** Vista immodificable: ningu no pot alterar el repositori per la porta del darrere. */
    public List<T> llistarTots() {
        return List.copyOf(perId.values());
    }

    /**
     * Filtra amb un predicat.
     * Predicate<? super T> per PECS: el predicat CONSUMEIX elements,
     * aixi que un Predicate<Identificable> tambe val.
     */
    public List<T> cercar(Predicate<? super T> criteri) {
        List<T> resultat = new ArrayList<>();
        for (T entitat : perId.values()) {
            if (criteri.test(entitat)) {
                resultat.add(entitat);
            }
        }
        return resultat;
    }

    /**
     * Ordena una copia.
     * Comparator<? super T> per PECS: un Comparator<Identificable> val
     * per ordenar qualsevol subtipus.
     */
    public List<T> llistarOrdenat(Comparator<? super T> ordre) {
        List<T> copia = new ArrayList<>(perId.values());
        copia.sort(ordre);
        return copia;
    }

    /**
     * Bolca totes les entitats al desti.
     * ? super T per PECS: el desti CONSUMEIX.
     */
    public void bolcarA(Collection<? super T> desti) {
        desti.addAll(perId.values());
    }

    @Override
    public String toString() {
        return "Repositori[" + nom + ", " + perId.size() + " entitats]";
    }
}

public abstract class Material implements Identificable {

    private final String isbn;
    private final String titol;
    // ... resta del modul 3

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

public class Prestec implements Identificable {

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

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

package com.nexussoftware.bibliotech;

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

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

public class BiblioTechApp {

    public static void main(String[] args) {

        Repositori<Material> cataleg = new Repositori<>("cataleg");
        Repositori<Prestec> prestecs = new Repositori<>("prestecs");

        cataleg.desar(new Llibre("Java Eficac", "978-0000000001"));
        cataleg.desar(new Llibre("Patrons de Disseny", "978-0000000002"));
        cataleg.desar(new Llibre("Refactoritzacio", "978-0000000003"));

        prestecs.desar(new Prestec("PR-2026-0041", "978-0000000001", "Marta Ruiz"));
        prestecs.desar(new Prestec("PR-2026-0042", "978-0000000003", "Diego Alonso"));

        // Ni una sola conversio en tot el que segueix.
        cataleg.cercarPerId("978-0000000001")
               .ifPresent(m -> System.out.println("Trobat: " + m.getTitol()));

        List<Material> ordenat =
                cataleg.llistarOrdenat(Comparator.comparing(Material::getTitol));
        ordenat.forEach(m -> System.out.println("  " + m.getTitol()));

        List<Prestec> deMarta = prestecs.cercar(p -> p.getEmpleat().equals("Marta Ruiz"));
        System.out.println("Prestecs de la Marta: " + deMarta.size());

        System.out.println(cataleg);
        System.out.println(prestecs);
    }
}

Trobat: Java Eficac
  Java Eficac
  Patrons de Disseny
  Refactoritzacio
Prestecs de la Marta: 1
Repositori[cataleg, 3 entitats]
Repositori[prestecs, 2 entitats]

package com.nexussoftware.bibliotech.servei;

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

/**
 * Resultat d una operacio que pot fallar de forma esperable.
 * O conte un valor de tipus T, o conte un missatge d error.
 * Mai les dues coses, mai cap.
 *
 * Constructor privat + fabriques estatiques: es impossible construir
 * un Resultat incoherent.
 */
public final class Resultat<T> {

    private final T valor;
    private final String error;

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

    /**
     * Metode generic estatic: declara la seva propia <U>, perque un
     * metode static NO pot fer servir la T de la classe (apartat 7).
     */
    public static <U> Resultat<U> exit(U valor) {
        return new Resultat<>(Objects.requireNonNull(valor, "valor"), null);
    }

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

    public boolean esExit()    { return error == null; }
    public boolean esFallada() { return error != null; }

    public T valor() {
        if (esFallada()) {
            throw new NoSuchElementException("El resultat es una fallada: " + error);
        }
        return valor;
    }

    public String error() {
        if (esExit()) {
            throw new NoSuchElementException("El resultat es un exit");
        }
        return error;
    }

    public T oPerDefecte(T alternativa) {
        return esExit() ? valor : alternativa;
    }

    /**
     * Transforma el valor si hi ha exit; propaga l error si no.
     * Function<? super T, ? extends R> per PECS:
     *   la funcio CONSUMEIX T -> ? super T
     *   la funcio PRODUEIX R  -> ? extends R
     */
    public <R> Resultat<R> map(Function<? super T, ? extends R> transformacio) {
        if (esFallada()) {
            return Resultat.fallada(error);     // l error viatja intacte
        }
        return Resultat.exit(transformacio.apply(valor));
    }

    /** Encadena operacions que al seu torn poden fallar, sense imbricar Resultat<Resultat<R>>. */
    public <R> Resultat<R> flatMap(Function<? super T, Resultat<R>> seguent) {
        return esFallada() ? Resultat.fallada(error) : seguent.apply(valor);
    }

    @Override
    public String toString() {
        return esExit() ? "Exit[" + valor + "]" : "Fallada[" + error + "]";
    }
}

package com.nexussoftware.bibliotech.servei;

import com.nexussoftware.bibliotech.domini.*;

public class GestorPrestecs {

    private final Repositori<Material> cataleg;
    private final Repositori<Prestec> prestecs;

    public GestorPrestecs(Repositori<Material> cataleg, Repositori<Prestec> prestecs) {
        this.cataleg = cataleg;
        this.prestecs = prestecs;
    }

    /** El tipus de retorn DIU que aixo pot fallar, i amb quin valor surt be. */
    public Resultat<Prestec> prestar(String isbn, String empleat) {

        Material material = cataleg.cercarPerId(isbn).orElse(null);
        if (material == null) {
            return Resultat.fallada("No existeix cap material amb ISBN " + isbn);
        }
        if (material.estaPrestat()) {
            return Resultat.fallada("El material '" + material.getTitol() + "' ja esta prestat");
        }

        material.marcarPrestat(empleat);
        Prestec prestec = new Prestec(seguentReferencia(), isbn, empleat);
        prestecs.desar(prestec);
        return Resultat.exit(prestec);
    }

    private String seguentReferencia() {
        return String.format("PR-2026-%04d", prestecs.mida() + 1);
    }
}

Resultat<Prestec> resultat = gestor.prestar("978-0000000001", "Nuria Vidal");

if (resultat.esExit()) {
    System.out.println("Prestec registrat: " + resultat.valor().getId());
} else {
    System.out.println("No s ha pogut prestar: " + resultat.error());
}

// Encadenament sense comprovacions intermedies
String rebut = gestor.prestar("978-0000000002", "Diego Alonso")
        .map(Prestec::getId)
        .map(id -> "Rebut num. " + id)
        .oPerDefecte("Sense rebut: el prestec no s ha pogut registrar");

System.out.println(rebut);

Prestec registrat: PR-2026-0043
Rebut num. PR-2026-0044

package com.nexussoftware.bibliotech.servei;

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

/**
 * Cache LRU generica amb capacitat maxima.
 *
 * K i V son independents: es pot tenir una Cache<String, Fitxa>
 * o una Cache<Integer, List<Prestec>> amb la mateixa classe.
 */
public class Cache<K, V> {

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

    private long encerts = 0;
    private long errades = 0;

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

        // Tercer argument true = ordre d ACCES (no d insercio): aixo es l LRU.
        // 0.75f es el factor de carrega habitual (reprem 05-05).
        this.mapa = new LinkedHashMap<>(capacitat, 0.75f, true) {
            @Override
            protected boolean removeEldestEntry(Map.Entry<K, V> mesAntiga) {
                // Quan retorna true, LinkedHashMap elimina l entrada mes antiga.
                return size() > Cache.this.capacitat;
            }
        };
    }

    /** Retorna Optional en lloc de null: l absencia es explicita (veure 10-04). */
    public Optional<V> obtenir(K clau) {
        V valor = mapa.get(clau);         // get() reordena per ser ordre d acces
        if (valor != null) {
            encerts++;
        } else {
            errades++;
        }
        return Optional.ofNullable(valor);
    }

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

    /**
     * PECS aplicat: la funcio CONSUMEIX la clau (? super K)
     * i PRODUEIX el valor (? extends V).
     * Aixi accepta una Function<Object, Fitxa> per a una Cache<String, Fitxa>.
     */
    public V obtenirOCalcular(K clau, Function<? super K, ? extends V> calcul) {
        V existent = mapa.get(clau);
        if (existent != null) {
            encerts++;
            return existent;
        }
        errades++;
        V calculat = calcul.apply(clau);
        mapa.put(clau, calculat);
        return calculat;
    }

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

    /** De la menys usada recentment a la mes recent. */
    public List<K> clausPerAntiguitat() {
        return new ArrayList<>(mapa.keySet());
    }

    public double taxaEncerts() {
        long total = encerts + errades;
        return total == 0 ? 0.0 : (double) encerts / total;
    }

    @Override
    public String toString() {
        return String.format("Cache[%d/%d entrades, %d encerts, %d errades, %.0f%% encert]",
                mapa.size(), capacitat, encerts, errades, taxaEncerts() * 100);
    }
}

public class ProvaCache {

    public static void main(String[] args) {

        Cache<String, Fitxa> fitxes = new Cache<>(3);

        // El calcul simula una consulta cara (llegir del CSV, o demanar per xarxa)
        Function<String, Fitxa> consultaCara = isbn -> {
            System.out.println("  [CALCULANT fitxa de " + isbn + "]");
            return new Fitxa(isbn, "Titol de " + isbn);
        };

        System.out.println("1) " + fitxes.obtenirOCalcular("978-0000000001", consultaCara));
        System.out.println("2) " + fitxes.obtenirOCalcular("978-0000000002", consultaCara));
        System.out.println("3) " + fitxes.obtenirOCalcular("978-0000000001", consultaCara)); // encert
        System.out.println("4) " + fitxes.obtenirOCalcular("978-0000000003", consultaCara));

        System.out.println("Claus abans de desbordar: " + fitxes.clausPerAntiguitat());

        // Aquesta quarta clau expulsa la menys usada recentment,
        // que es ...0002 (la ...0001 es va refrescar al pas 3).
        System.out.println("5) " + fitxes.obtenirOCalcular("978-0000000004", consultaCara));

        System.out.println("Claus despres:            " + fitxes.clausPerAntiguitat());
        System.out.println(fitxes);
    }
}

  [CALCULANT fitxa de 978-0000000001]
1) Fitxa[978-0000000001, Titol de 978-0000000001]
  [CALCULANT fitxa de 978-0000000002]
2) Fitxa[978-0000000002, Titol de 978-0000000002]
3) Fitxa[978-0000000001, Titol de 978-0000000001]
  [CALCULANT fitxa de 978-0000000003]
4) Fitxa[978-0000000003, Titol de 978-0000000003]
Claus abans de desbordar: [978-0000000002, 978-0000000001, 978-0000000003]
  [CALCULANT fitxa de 978-0000000004]
5) Fitxa[978-0000000004, Titol de 978-0000000004]
Claus despres:            [978-0000000001, 978-0000000003, 978-0000000004]
Cache[3/3 entrades, 1 encerts, 4 errades, 20% encert]

package com.nexussoftware.bibliotech.servei;

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

public final class Agregador {

    private Agregador() { }   // classe d utilitat: no s instancia

    /**
     * PRODUEIX nombres que llegim -> ? extends Number.
     * Aixi accepta List<Integer>, List<Double>, List<Long>...
     * Amb Collection<Number> NO acceptaria un List<Integer> (invariancia).
     */
    public static double sumar(Collection<? extends Number> nombres) {
        double total = 0;
        for (Number n : nombres) {
            total += n.doubleValue();
        }
        return total;
    }

    /**
     * origen  PRODUEIX  -> ? extends T
     * desti   CONSUMEIX -> ? super T
     * criteri CONSUMEIX -> Predicate<? super T>
     */
    public static <T> int copiarFiltrant(Collection<? extends T> origen,
                                         Collection<? super T> desti,
                                         Predicate<? super T> criteri) {
        int copiats = 0;
        for (T element : origen) {
            if (criteri.test(element)) {
                desti.add(element);
                copiats++;
            }
        }
        return copiats;
    }

    /**
     * elements PRODUEIX  -> ? extends T
     * ordre    CONSUMEIX -> Comparator<? super T>
     * El retorn NO porta comodi: Optional<T> net.
     */
    public static <T> Optional<T> maximSegons(Collection<? extends T> elements,
                                              Comparator<? super T> ordre) {
        Iterator<? extends T> it = elements.iterator();
        if (!it.hasNext()) {
            return Optional.empty();
        }
        T major = it.next();
        while (it.hasNext()) {
            T candidat = it.next();
            if (ordre.compare(candidat, major) > 0) {
                major = candidat;
            }
        }
        return Optional.of(major);
    }
}

public class ProvaAgregador {

    public static void main(String[] args) {

        // 1) sumar accepta qualsevol colleccio de subtipus de Number
        List<Integer> pagines = List.of(412, 395, 448);
        List<Double>  multes  = List.of(1.50, 0.75, 3.20);

        System.out.printf("Pagines totals: %.0f%n", Agregador.sumar(pagines));
        System.out.printf("Multes totals:  %.2f €%n", Agregador.sumar(multes));

        // 2) origen List<Llibre>, desti List<Material>: dos tipus DIFERENTS
        List<Llibre> llibres = new ArrayList<>(List.of(
                new Llibre("Java Eficac",        "978-0000000001", 412, true),
                new Llibre("Patrons de Disseny", "978-0000000002", 395, false),
                new Llibre("Refactoritzacio",    "978-0000000003", 448, true)));

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

        int copiats = Agregador.copiarFiltrant(llibres, prestats, Llibre::estaPrestat);
        System.out.println("Copiats a la llista de materials: " + copiats);
        prestats.forEach(m -> System.out.println("  " + m.getTitol()));

        // 3) Comparator<Material> ordenant una List<Llibre>: gracies al ? super T
        Comparator<Material> perTitol = Comparator.comparing(Material::getTitol);

        Agregador.maximSegons(llibres, perTitol)
                 .ifPresent(l -> System.out.println("Ultim alfabeticament: " + l.getTitol()));

        // I el maxim retorna Llibre, no Material: el tipus es conserva
        Optional<Llibre> ultim = Agregador.maximSegons(llibres, perTitol);
        System.out.println("El tipus estatic es Llibre: " + ultim.map(Llibre::getIsbn).orElse("-"));
    }
}

Pagines totals: 1255
Multes totals:  5,45 €
Copiats a la llista de materials: 2
  Java Eficac
  Refactoritzacio
Ultim alfabeticament: Refactoritzacio
El tipus estatic es Llibre: 978-0000000003

package com.nexussoftware.bibliotech.servei;

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

/**
 * Validador generic i encadenable.
 * Acumula regles i retorna un Resultat<T> amb TOTES les fallades,
 * no nomes la primera: qui omple un formulari agraeix veure-les juntes.
 */
public final class ValidadorEncadenable<T> {

    /** Parell regla-missatge. Un record generic (04-07 + aquest apartat 3). */
    private record Regla<T>(Predicate<? super T> condicio, String missatge) { }

    private final String nomTipus;
    private final List<Regla<T>> regles = new ArrayList<>();

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

    /**
     * Testimoni de tipus (apartat 19): el Class<T> aporta el nom llegible
     * i a mes fixa T sense necessitat d escriure-la.
     */
    public static <T> ValidadorEncadenable<T> de(Class<T> tipus) {
        return new ValidadorEncadenable<>(tipus.getSimpleName());
    }

    /**
     * Retorna this per encadenar.
     * Predicate<? super T> per PECS: la regla CONSUMEIX l objecte,
     * aixi que un Predicate<Object> o un Predicate<Material> tambe valen.
     */
    public ValidadorEncadenable<T> ambRegla(Predicate<? super T> condicio, String missatge) {
        regles.add(new Regla<>(Objects.requireNonNull(condicio, "condicio"),
                               Objects.requireNonNull(missatge, "missatge")));
        return this;
    }

    public Resultat<T> validar(T objecte) {
        if (objecte == null) {
            return Resultat.fallada("El " + nomTipus + " es nul");
        }

        List<String> fallades = new ArrayList<>();
        for (Regla<T> regla : regles) {
            if (!regla.condicio().test(objecte)) {
                fallades.add(regla.missatge());
            }
        }

        if (fallades.isEmpty()) {
            return Resultat.exit(objecte);
        }
        return Resultat.fallada(nomTipus + " no valid: " + String.join("; ", fallades));
    }

    public int nombreDeRegles() {
        return regles.size();
    }
}

public class ProvaValidador {

    public static void main(String[] args) {

        ValidadorEncadenable<Llibre> validador = ValidadorEncadenable.de(Llibre.class)
                .ambRegla(l -> l.getIsbn() != null,                  "l'ISBN es obligatori")
                .ambRegla(l -> l.getIsbn() != null
                            && l.getIsbn().length() == 17,           "l'ISBN ha de tenir 17 caracters")
                .ambRegla(l -> l.getTitol() != null
                            && !l.getTitol().isBlank(),              "el titol no pot estar buit")
                .ambRegla(l -> l.getTitol() == null
                            || l.getTitol().length() < 200,          "el titol supera els 200 caracters");

        System.out.println("Regles configurades: " + validador.nombreDeRegles());

        List<Llibre> candidats = List.of(
                new Llibre("Java Eficac",        "978-0000000001"),
                new Llibre("Patrons de Disseny", "978-1"),
                new Llibre("",                   "978-0000000003"));

        for (Llibre candidat : candidats) {
            Resultat<Llibre> resultat = validador.validar(candidat);

            // Encadenament amb map: nomes s executa si hi va haver exit
            String linia = resultat
                    .map(Llibre::getTitol)
                    .map(t -> "ACCEPTAT: " + t)
                    .oPerDefecte("REBUTJAT: " + (resultat.esFallada() ? resultat.error() : ""));

            System.out.println(linia);
        }

        // El validador es reutilitzable amb qualsevol Predicate<Material>
        Predicate<Material> teTitol = m -> m.getTitol() != null;
        ValidadorEncadenable<Llibre> altre = ValidadorEncadenable.de(Llibre.class)
                .ambRegla(teTitol, "necessita titol");   // Predicate<Material> en un validador de Llibre
        System.out.println(altre.validar(new Llibre("Refactoritzacio", "978-0000000003")));
    }
}

Regles configurades: 4
ACCEPTAT: Java Eficac
REBUTJAT: Llibre no valid: l'ISBN ha de tenir 17 caracters
REBUTJAT: Llibre no valid: el titol no pot estar buit
Exit[Llibre[Refactoritzacio, 978-0000000003]]