public interface Comparable<T> {
    int compareTo(T altre);
}

package com.nexussoftware.bibliotech.domini;

/** Fitxa bibliografica amb ordre natural per titol. */
public record Fitxa(String titol, String autor, int any) implements Comparable<Fitxa> {

    public Fitxa {
        if (titol == null || titol.isBlank()) { titol = "Sense titol"; }
        if (autor == null || autor.isBlank()) { autor = "Desconegut"; }
        if (any < 1450 || any > 2100)         { any   = 0; }
    }

    /** Ordre natural: per titol alfabetic. */
    @Override
    public int compareTo(Fitxa altra) {
        return this.titol.compareTo(altra.titol);    // String ja implementa Comparable
    }
}

List<Fitxa> fitxes = new ArrayList<>(List.of(
    new Fitxa("Refactoritzacio",    "Martin Fowler", 1999),
    new Fitxa("Java Eficac",        "Joshua Bloch",  2018),
    new Fitxa("Patrons de Disseny", "Erich Gamma",   1994)));

fitxes.sort(null);                        // null = ordre natural
Collections.sort(fitxes);                 // equivalent
System.out.println(fitxes.get(0).titol()); // Java Eficac

TreeSet<Fitxa> ordenades = new TreeSet<>(fitxes);        // el TreeSet usa compareTo
Fitxa minima = Collections.min(fitxes);                  // tambe

// VIOLA l'antisimetria: sempre diu "vaig abans"
@Override public int compareTo(Fitxa altra) { return -1; }

// VIOLA la transitivitat: l'ordre depen d'alguna cosa que canvia
@Override public int compareTo(Fitxa altra) {
    return Double.compare(Math.random(), 0.5);
}

// VIOLA la consistencia: compara camps diferents segons el cas
@Override public int compareTo(Fitxa altra) {
    if (this.any > 2000) { return this.titol.compareTo(altra.titol); }
    return Integer.compare(this.any, altra.any);
}

// MALAMENT: sembla correcte i funciona... fins que no
@Override
public int compareTo(Fitxa altra) {
    return this.any - altra.any;
}

int a = 2_000_000_000;
int b = -2_000_000_000;

System.out.println(a - b);                 // -294967296   <- NEGATIU, i a > b !
System.out.println(Integer.compare(a, b)); // 1            <- correcte

Integer.compare(a, b)      // per a int
Long.compare(a, b)         // per a long
Double.compare(a, b)       // per a double: a mes tracta be NaN i -0.0
Boolean.compare(a, b)      // false < true
Character.compare(a, b)

// BE
@Override
public int compareTo(Fitxa altra) {
    return Integer.compare(this.any, altra.any);
}

// MALAMENT
return (int) (this.tarifa - altra.tarifa);   // 0.25 - 0.10 = 0.15 -> (int) 0 -> "iguals"!

// BE
return Double.compare(this.tarifa, altra.tarifa);

package com.nexussoftware.bibliotech.domini;

/** Fitxa amb ordre natural per ANY: incoherent amb equals. */
record FitxaPerAny(String titol, String autor, int any)
        implements Comparable<FitxaPerAny> {

    @Override
    public int compareTo(FitxaPerAny altra) {
        return Integer.compare(this.any, altra.any);    // nomes l'any
    }
}

FitxaPerAny a = new FitxaPerAny("Java Eficac",        "Joshua Bloch", 2018);
FitxaPerAny b = new FitxaPerAny("Patrons de Disseny", "Erich Gamma",  2018);

System.out.println(a.equals(b));        // false: son fitxes DIFERENTS
System.out.println(a.compareTo(b));     // 0:     pero EMPATEN en l'ordre

// En una List no passa res
List<FitxaPerAny> llista = new ArrayList<>(List.of(a, b));
System.out.println(llista.size());      // 2   correcte

// En un TreeSet, si
TreeSet<FitxaPerAny> conjunt = new TreeSet<>(List.of(a, b));
System.out.println(conjunt.size());     // 1   <-- S'HA PERDUT UNA FITXA

// I contains menteix
System.out.println(conjunt.contains(b));   // true, encara que b no hi sigui

TreeMap<FitxaPerAny, String> mapa = new TreeMap<>();
mapa.put(a, "Prestatge A-3");
mapa.put(b, "Prestatge B-1");
System.out.println(mapa.size());      // 1: b ha SUBSTITUIT a
System.out.println(mapa.get(a));      // Prestatge B-1  <-- valor equivocat

@Override
public int compareTo(FitxaPerAny altra) {
    int perAny = Integer.compare(this.any, altra.any);
    if (perAny != 0) { return perAny; }
    int perTitol = this.titol.compareTo(altra.titol);
    if (perTitol != 0) { return perTitol; }
    return this.autor.compareTo(altra.autor);   // els tres camps: coherent amb equals
}

private static final Comparator<FitxaPerAny> ORDRE =
    Comparator.comparingInt(FitxaPerAny::any)
              .thenComparing(FitxaPerAny::titol)
              .thenComparing(FitxaPerAny::autor);

@Override
public int compareTo(FitxaPerAny altra) { return ORDRE.compare(this, altra); }

public interface Comparator<T> {
    int compare(T a, T b);
}

// 1. Classe anonima: la forma classica (04-04)
Comparator<Material> perTitol = new Comparator<Material>() {
    @Override public int compare(Material a, Material b) {
        return a.getTitol().compareTo(b.getTitol());
    }
};

// 2. Lambda (04-05)
Comparator<Material> perTitol2 = (a, b) -> a.getTitol().compareTo(b.getTitol());

// 3. Comparator.comparing amb referencia a metode: la forma moderna (04-06)
Comparator<Material> perTitol3 = Comparator.comparing(Material::getTitol);

Comparator.comparing(Material::getTitol)                     // per una clau Comparable
Comparator.comparingInt(Prestec::getDiaPrestec)              // clau int: SENSE autoboxing
Comparator.comparingLong(Registre::getMarcaTemps)            // clau long
Comparator.comparingDouble(Material::getTarifaDiaria)        // clau double
Comparator.naturalOrder()                                    // l'ordre natural del tipus
Comparator.reverseOrder()                                    // l'ordre natural invertit

Comparator<Material> criteri =
    Comparator.comparing(Material::getTipus)                  // primer per tipus
              .thenComparing(Material::getTitol)              // a igualtat, per titol
              .thenComparingDouble(Material::getTarifaDiaria); // i despres per tarifa

Comparator<Material> carPrimer = Comparator.comparingDouble(Material::getTarifaDiaria)
                                           .reversed();

// Inverteix TOTS DOS criteris: tipus descendent i, a igualtat, titol descendent
Comparator.comparing(Material::getTipus)
          .thenComparing(Material::getTitol)
          .reversed();

// Inverteix NOMES el titol: tipus ascendent, titol descendent
Comparator.comparing(Material::getTipus)
          .thenComparing(Material::getTitol, Comparator.reverseOrder());

Comparator<Material> segur  = Comparator.nullsFirst(Comparator.comparing(Material::getTitol));
Comparator<Material> alFinal = Comparator.nullsLast(Comparator.comparing(Material::getTitol));

Comparator<Material> perAutor = Comparator.comparing(
    m -> ((Llibre) m).getAutor(),
    Comparator.nullsLast(Comparator.naturalOrder()));

public final class OrdresMaterial {
    public static final Comparator<Material> PER_TITOL =
        Comparator.comparing(Material::getTitol);
    public static final Comparator<Material> PER_TIPUS_I_TITOL =
        Comparator.comparing(Material::getTipus).thenComparing(Material::getTitol);
    public static final Comparator<Material> PER_TARIFA_DESC =
        Comparator.comparingDouble(Material::getTarifaDiaria).reversed()
                  .thenComparing(Material::getReferencia);   // desempat per a ordre total
    private OrdresMaterial() { }
}

cataleg.ordenar(OrdresMaterial.PER_TIPUS_I_TITOL);

// 1. List.sort: el metode propi de la interficie. L'OPCIO PER DEFECTE
cataleg.sort(Comparator.comparing(Material::getTitol));
cataleg.sort(null);                                     // ordre natural

// 2. Collections.sort: anterior a Java 8, fa el mateix
Collections.sort(fitxes);                               // ordre natural
Collections.sort(cataleg, Comparator.comparing(Material::getTitol));

// 3. Arrays.sort
Material[] array = cataleg.toArray(new Material[0]);
Arrays.sort(array, Comparator.comparing(Material::getTitol));
Arrays.sort(array, 0, 10, comparador);                  // nomes un rang

// 4. Colleccions que es mantenen ordenades
TreeSet<Fitxa> sempreOrdenades = new TreeSet<>();        // per compareTo
TreeMap<String, Material> perClau = new TreeMap<>();     // claus ordenades
PriorityQueue<Prestec> perUrgencia = new PriorityQueue<>(comparador);  // nomes el cap

List<Fitxa> fitxes = new ArrayList<>(List.of(
    new Fitxa("Refactoritzacio",    "Martin Fowler", 1999),
    new Fitxa("Java Eficac",        "Joshua Bloch",  2018),
    new Fitxa("Patrons de Disseny", "Erich Gamma",   1994),
    new Fitxa("Codi Net",           "Robert Martin", 2008)));

// Primer per autor
fitxes.sort(Comparator.comparing(Fitxa::autor));
// Despres per any
fitxes.sort(Comparator.comparingInt(Fitxa::any));

// Estrategia A: passades successives (del criteri MENYS important al MES important)
cataleg.sort(Comparator.comparing(Material::getTitol));       // secundari
cataleg.sort(Comparator.comparing(Material::getTipus));       // primari

// Estrategia B: un comparador compost
cataleg.sort(Comparator.comparing(Material::getTipus)
                       .thenComparing(Material::getTitol));

boolean conte = cataleg.contains(material);          // O(n), usa equals
int posicio = cataleg.indexOf(material);             // O(n)

Material trobat = null;                              // cerca per criteri
for (Material m : cataleg) {
    if (m.getReferencia().equals("978-0000000001")) { trobat = m; break; }
}

List<Fitxa> fitxes = new ArrayList<>(...);
fitxes.sort(null);                                   // OBLIGATORI ordenar primer

int pos = Collections.binarySearch(fitxes, buscada);
int pos2 = Collections.binarySearch(cataleg, sonda,
                                    Comparator.comparing(Material::getReferencia));

int pos3 = Arrays.binarySearch(array, buscat);

Map<String, Material> index = new HashMap<>();
Material m = index.get("978-0000000001");            // O(1)
boolean existeix = referencies.contains("978-0000000001");  // O(1)

List<Integer> ordenada = new ArrayList<>(List.of(10, 20, 30, 40, 50));

System.out.println(Collections.binarySearch(ordenada, 30));   //  2  (es a l'index 2)
System.out.println(Collections.binarySearch(ordenada, 35));   // -4  (aniria a l'index 3)
System.out.println(Collections.binarySearch(ordenada, 5));    // -1  (aniria a l'index 0)
System.out.println(Collections.binarySearch(ordenada, 99));   // -6  (aniria a l'index 5)

int resultat = Collections.binarySearch(ordenada, 35);
if (resultat >= 0) {
    System.out.println("Trobat a la posicio " + resultat);
} else {
    int puntInsercio = -resultat - 1;                    // -(-4) - 1 = 3
    System.out.println("No hi es; aniria a la posicio " + puntInsercio);
    ordenada.add(puntInsercio, 35);                      // insercio ordenada
}

List<Integer> desordenada = new ArrayList<>(List.of(30, 10, 50, 20, 40));
System.out.println(Collections.binarySearch(desordenada, 50));   // -3, i el 50 hi es

cataleg.sort(Comparator.comparing(Material::getTitol));

// MALAMENT: ordenat per titol, buscat per referencia
Collections.binarySearch(cataleg, sonda, Comparator.comparing(Material::getReferencia));

// BE: el mateix comparador en tots dos
Comparator<Material> perTitol = Comparator.comparing(Material::getTitol);
cataleg.sort(perTitol);
Collections.binarySearch(cataleg, sonda, perTitol);

List<Fitxa> fitxes = new ArrayList<>(...);

// Extrems, amb ordre natural o amb Comparator
Fitxa primera = Collections.min(fitxes);
Fitxa ultima  = Collections.max(fitxes);
Material car  = Collections.max(cataleg, Comparator.comparingDouble(Material::getTarifaDiaria));

// Comptar aparicions (usa equals)
int quants = Collections.frequency(cataleg, javaEficac);

// Modificar la llista al lloc
Collections.reverse(fitxes);           // inverteix l'ordre. O(n)
Collections.shuffle(fitxes);           // barreja aleatoriament. O(n)
Collections.swap(fitxes, 0, 3);        // intercanvia dues posicions. O(1)
Collections.rotate(fitxes, 2);         // desplaca 2 posicions circularment
Collections.fill(fitxes, plantilla);   // omple tot amb el mateix element

// Crear
List<String> repes = Collections.nCopies(3, "pendent");     // llista IMMUTABLE de 3 iguals
Collections.addAll(cataleg, m1, m2, m3);                    // afegir-ne diversos de cop

// Consultar
boolean senseRelacio = Collections.disjoint(ambPrestec, ambRetard);  // sense elements comuns

// Vistes i colleccions especials (05-02)
List<Material> nomesLectura = Collections.unmodifiableList(cataleg);
List<Material> buida = Collections.emptyList();
List<Material> un = Collections.singletonList(javaEficac);

package com.nexussoftware.bibliotech.servei;

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Set;
import java.util.TreeMap;
import java.util.function.Predicate;
import com.nexussoftware.bibliotech.domini.*;

/** BiblioTech al tancament del modul 5: totes les estructures al seu lloc. */
public class BiblioTech {

    // --- Cataleg: llista per a l'ordre, mapes per als indexs ---
    private final List<Material>              cataleg       = new ArrayList<>();
    private final Map<String, Material>       perReferencia = new HashMap<>();
    private final Map<String, List<Material>> perTipus      = new HashMap<>();
    private final Set<String>                 isbnVistos    = new HashSet<>();

    // --- Prestecs ---
    private final Map<String, Prestec>          prestecs   = new HashMap<>();
    private final Map<Empleat, List<Prestec>>   perEmpleat = new HashMap<>();

    // --- Reserves: una cua FIFO per material ---
    private final Map<String, Deque<Reserva>> reserves = new HashMap<>();

    // --- Historial reversible ---
    private final Deque<OperacioCataleg> desfer = new ArrayDeque<>();

    // --- Comparadors reutilitzables ---
    public static final Comparator<Material> PER_TITOL =
        Comparator.comparing(Material::getTitol);
    public static final Comparator<Material> PER_TIPUS_I_TITOL =
        Comparator.comparing(Material::getTipus).thenComparing(Material::getTitol);
    public static final Comparator<Material> PER_TARIFA_DESC =
        Comparator.comparingDouble(Material::getTarifaDiaria).reversed()
                  .thenComparing(Material::getReferencia);      // desempat: ordre TOTAL

    // ---------- Cataleg ----------

    public boolean donarDeAlta(Material m, int dia) {
        if (m == null || !isbnVistos.add(m.getReferencia())) { return false; }
        cataleg.add(m);
        perReferencia.put(m.getReferencia(), m);
        perTipus.computeIfAbsent(m.getTipus(), t -> new ArrayList<>()).add(m);
        desfer.push(new OperacioCataleg(OperacioCataleg.Tipus.ALTA, m, dia));
        return true;
    }

    public boolean donarDeBaixa(String referencia, int dia) {
        Material m = perReferencia.remove(referencia);
        if (m == null) { return false; }
        isbnVistos.remove(referencia);
        cataleg.remove(m);
        perTipus.computeIfPresent(m.getTipus(),
                (t, llista) -> { llista.remove(m); return llista.isEmpty() ? null : llista; });
        desfer.push(new OperacioCataleg(OperacioCataleg.Tipus.BAIXA, m, dia));
        return true;
    }

    /** Cerca per clau: O(1). */
    public Material cercar(String referencia) { return perReferencia.get(referencia); }

    /** Cerca per criteri arbitrari: O(n), inevitable. */
    public List<Material> cercar(Predicate<Material> criteri) {
        List<Material> resultat = new ArrayList<>();
        for (Material m : cataleg) {
            if (criteri.test(m)) { resultat.add(m); }
        }
        return resultat;
    }

    public List<Material> llistar(Comparator<Material> criteri) {
        List<Material> copia = new ArrayList<>(cataleg);
        copia.sort(criteri);                        // TimSort, O(n log n), estable
        return copia;
    }

    // ---------- Prestecs ----------

    public boolean prestar(String referencia, Empleat empleat, int dia) {
        Material m = perReferencia.get(referencia);
        if (m == null || !m.estaDisponible() || !empleat.potPrendrePrestat()) {
            return false;
        }
        Prestec p = new Prestec(m, empleat, dia);
        prestecs.put(p.getReferencia(), p);
        perEmpleat.computeIfAbsent(empleat, e -> new ArrayList<>()).add(p);
        m.prestar();
        empleat.registrarPrestec();
        return true;
    }

    public boolean retornar(String referenciaPrestec, int dia) {
        Prestec p = prestecs.get(referenciaPrestec);          // O(1)
        if (p == null || p.estaRetornat()) { return false; }
        p.registrarDevolucio(dia);
        p.getEmpleat().registrarDevolucio();

        // Atendre la primera reserva del material, si n'hi ha
        Deque<Reserva> cua = reserves.get(p.getMaterial().getReferencia());
        if (cua != null) {
            Reserva seguent = cua.pollFirst();
            if (seguent != null) {
                seguent.marcarAtesa();
                System.out.printf("AVIS: %s pot recollir '%s'%n",
                        seguent.getEmpleat().getNom(), p.getMaterial().getTitol());
            }
        }
        return true;
    }

    public void reservar(String referencia, Empleat empleat, int dia) {
        Material m = perReferencia.get(referencia);
        if (m == null) { return; }
        reserves.computeIfAbsent(referencia, r -> new ArrayDeque<>())
                .offerLast(new Reserva(empleat, m, dia));
    }

    // ---------- Informes ----------

    /** Comptadors per tipus, en un TreeMap perque surtin sempre ordenats. */
    public Map<String, Integer> informePerTipus() {
        Map<String, Integer> resum = new TreeMap<>();
        for (Material m : cataleg) { resum.merge(m.getTipus(), 1, Integer::sum); }
        return resum;
    }

    /** Rànquing d'empleats per multa acumulada, de major a menor. */
    public Map<Empleat, Double> rankingMultes(int diaActual) {
        Map<Empleat, Double> multes = new HashMap<>();
        for (List<Prestec> llista : perEmpleat.values()) {
            for (Prestec p : llista) {
                double multa = p.calcularMulta(diaActual);
                if (multa > 0) { multes.merge(p.getEmpleat(), multa, Double::sum); }
            }
        }
        // Un mapa NO s'ordena per valor: cal abocar, ordenar i reconstruir
        List<Map.Entry<Empleat, Double>> entrades = new ArrayList<>(multes.entrySet());
        entrades.sort(Map.Entry.<Empleat, Double>comparingByValue().reversed());

        Map<Empleat, Double> ordenat = new LinkedHashMap<>();   // conserva l'ordre
        for (Map.Entry<Empleat, Double> e : entrades) {
            ordenat.put(e.getKey(), e.getValue());
        }
        return ordenat;
    }

    /** Els N prestecs mes urgents, amb PriorityQueue. */
    public List<Prestec> mesUrgents(int quants, int diaActual) {
        Queue<Prestec> cua = new PriorityQueue<>(
            Comparator.comparingDouble((Prestec p) -> p.calcularMulta(diaActual)).reversed()
                      .thenComparing(Prestec::getReferencia));
        for (Prestec p : prestecs.values()) {
            if (!p.estaRetornat() && p.estaVencut(diaActual)) { cua.offer(p); }
        }
        List<Prestec> resultat = new ArrayList<>();
        for (int i = 0; i < quants && !cua.isEmpty(); i++) {
            resultat.add(cua.poll());                // poll: l'UNIC ordre garantit
        }
        return resultat;
    }

    /** El material mes car: min/max son O(n), no cal ordenar. */
    public Material mesCar() {
        return cataleg.isEmpty() ? null
             : Collections.max(cataleg, Comparator.comparingDouble(Material::getTarifaDiaria));
    }

    public OperacioCataleg ultimaOperacio() { return desfer.peek(); }
    public int midaCataleg() { return cataleg.size(); }
}

BiblioTech app = new BiblioTech();

Empleat marta = new Empleat("Marta Ruiz",   "EMP-001");
Empleat diego = new Empleat("Diego Alonso", "EMP-002");
Empleat nuria = new Empleat("Nuria Vidal",  "EMP-003");

app.donarDeAlta(new Llibre("Java Eficac",        "Joshua Bloch",  "978-0000000001", 2018), 100);
app.donarDeAlta(new Llibre("Patrons de Disseny", "Erich Gamma",   "978-0000000002", 1994), 100);
app.donarDeAlta(new Llibre("Refactoritzacio",    "Martin Fowler", "978-0000000003", 1999), 100);
app.donarDeAlta(new Revista("Java Magazine",     "REV-2024-03",   42, "Mensual"),          101);
app.donarDeAlta(new Dvd("Refactoritzacio en directe", "DVD-0007", 95),                     101);

System.out.println("=== Cataleg per tipus i titol ===");
app.llistar(BiblioTech.PER_TIPUS_I_TITOL)
   .forEach(m -> System.out.printf("  %-8s %-26s %.2f EUR/dia%n",
           m.getTipus(), m.getTitol(), m.getTarifaDiaria()));

app.prestar("978-0000000001", marta, 100);
app.prestar("978-0000000003", marta, 102);
app.prestar("DVD-0007",       diego, 105);
app.reservar("978-0000000001", nuria, 106);       // Java Eficac esta prestat

System.out.println("\n=== Informe per tipus ===");
app.informePerTipus().forEach((t, n) -> System.out.printf("  %-8s %d%n", t, n));

System.out.println("\n=== Prestecs mes urgents (dia 140) ===");
app.mesUrgents(3, 140).forEach(p -> System.out.printf("  %-16s %-26s %6.2f EUR%n",
        p.getEmpleat().getNom(), p.getMaterial().getTitol(), p.calcularMulta(140)));

System.out.println("\n=== Ranquing de multes (dia 140) ===");
app.rankingMultes(140).forEach((e, multa) ->
        System.out.printf("  %-16s %6.2f EUR%n", e.getNom(), multa));

System.out.println("\n=== Devolucio amb reserva pendent ===");
app.retornar("PR-0001", 140);

System.out.println("\nMaterial mes car: " + app.mesCar().getTitol());
System.out.println("Ultima operacio:  " + app.ultimaOperacio());

=== Cataleg per tipus i titol ===
  DVD      Refactoritzacio en directe 0,50 EUR/dia
  Llibre   Java Eficac                0,25 EUR/dia
  Llibre   Patrons de Disseny         0,25 EUR/dia
  Llibre   Refactoritzacio            0,25 EUR/dia
  Revista  Java Magazine              0,10 EUR/dia

=== Informe per tipus ===
  DVD      1
  Llibre   3
  Revista  1

=== Prestecs mes urgents (dia 140) ===
  Diego Alonso     Refactoritzacio en directe  16,00 EUR
  Marta Ruiz       Java Eficac                  6,25 EUR
  Marta Ruiz       Refactoritzacio              5,75 EUR

=== Ranquing de multes (dia 140) ===
  Diego Alonso      16,00 EUR
  Marta Ruiz        12,00 EUR

=== Devolucio amb reserva pendent ===
AVIS: Nuria Vidal pot recollir 'Java Eficac'

Material mes car: Refactoritzacio en directe
Ultima operacio: Alta de material de 'Refactoritzacio en directe' (DVD-0007) el dia 101

package com.nexussoftware.bibliotech.servei;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import com.nexussoftware.bibliotech.domini.Llibre;
import com.nexussoftware.bibliotech.domini.Material;

public class CatalegOrdenable {

    private final List<Material> materials = new ArrayList<>();
    private Comparator<Material> ordreActual = null;   // recorda com esta ordenat

    /** Comparadors reutilitzables. TOTS acaben amb un desempat per referencia. */
    public static final class Ordres {
        private Ordres() { }

        public static final Comparator<Material> PER_TITOL =
            Comparator.comparing(Material::getTitol)
                      .thenComparing(Material::getReferencia);

        public static final Comparator<Material> PER_TIPUS_I_TITOL =
            Comparator.comparing(Material::getTipus)
                      .thenComparing(Material::getTitol)
                      .thenComparing(Material::getReferencia);

        // comparingDouble: sense autoboxing. reversed() abans del desempat,
        // perque la referencia continui ordenant-se ASCENDENT.
        public static final Comparator<Material> PER_TARIFA_DESC =
            Comparator.comparingDouble(Material::getTarifaDiaria).reversed()
                      .thenComparing(Material::getReferencia);

        // Els disponibles primer: false < true, aixi que cal invertir el boolea
        public static final Comparator<Material> PER_DISPONIBILITAT =
            Comparator.comparing((Material m) -> !m.estaDisponible())
                      .thenComparing(Material::getTitol)
                      .thenComparing(Material::getReferencia);

        // Tipus ASCENDENT, tarifa DESCENDENT: cada criteri amb la seva direccio.
        // Un .reversed() al final invertiria TAMBE el tipus: error classic.
        public static final Comparator<Material> PER_TIPUS_I_TARIFA_DESC =
            Comparator.comparing(Material::getTipus)
                      .thenComparing(Material::getTarifaDiaria, Comparator.reverseOrder())
                      .thenComparing(Material::getReferencia);
    }

    public void afegir(Material m) {
        if (m != null) { materials.add(m); ordreActual = null; }    // es perd l'ordre
    }

    /** Copia ordenada: el cataleg original conserva el seu ordre. */
    public List<Material> ordenatPer(Comparator<Material> criteri) {
        List<Material> copia = new ArrayList<>(materials);
        copia.sort(criteri);
        return copia;
    }

    public void ordenarAlLloc(Comparator<Material> criteri) {
        materials.sort(criteri);
        ordreActual = criteri;
    }

    /** max/min son O(n): molt millor que ordenar (O(n log n)) per a un sol extrem. */
    public Material maxim(Comparator<Material> criteri) {
        return materials.isEmpty() ? null : Collections.max(materials, criteri);
    }

    public Material minim(Comparator<Material> criteri) {
        return materials.isEmpty() ? null : Collections.min(materials, criteri);
    }

    public List<Material> topN(int n, Comparator<Material> criteri) {
        List<Material> ordenat = ordenatPer(criteri);
        return new ArrayList<>(ordenat.subList(0, Math.min(n, ordenat.size())));
    }

    /**
     * Cerca binaria per titol. Ordena nomes si cal i fa servir
     * el MATEIX comparador per ordenar i per cercar: requisit imprescindible.
     */
    public int cercarBinari(String titol) {
        if (titol == null) { return -1; }

        Comparator<Material> criteri = Ordres.PER_TITOL;
        if (ordreActual != criteri) {
            ordenarAlLloc(criteri);           // O(n log n), pero nomes la primera vegada
        }

        // binarySearch necessita un ELEMENT, no una clau solta: cal una sonda.
        // Es un inconvenient real, i una rao mes per preferir un Map (05-05).
        Material sonda = new Llibre(titol, "", "", 2000);
        int resultat = Collections.binarySearch(materials, sonda,
                Comparator.comparing(Material::getTitol));    // nomes el titol: la sonda
                                                              // no te referencia valida

        if (resultat >= 0) {
            System.out.printf("'%s' trobat a la posicio %d%n", titol, resultat);
        } else {
            int puntInsercio = -resultat - 1;         // la formula: -(pos) - 1
            System.out.printf("'%s' no hi es; aniria a la posicio %d%n", titol, puntInsercio);
        }
        return resultat;
    }

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

CatalegOrdenable c = new CatalegOrdenable();
c.afegir(new Llibre("Refactoritzacio",    "Martin Fowler", "978-0000000003", 1999));
c.afegir(new Llibre("Java Eficac",        "Joshua Bloch",  "978-0000000001", 2018));
c.afegir(new Revista("Java Magazine",     "REV-2024-03",   42, "Mensual"));
c.afegir(new Dvd("Refactoritzacio en directe", "DVD-0007", 95));
c.afegir(new Llibre("Patrons de Disseny", "Erich Gamma",   "978-0000000002", 1994));

System.out.println("--- Per tipus i tarifa descendent ---");
c.ordenatPer(CatalegOrdenable.Ordres.PER_TIPUS_I_TARIFA_DESC)
 .forEach(m -> System.out.printf("  %-8s %-26s %.2f%n",
         m.getTipus(), m.getTitol(), m.getTarifaDiaria()));

System.out.println("Mes car: " + c.maxim(
        Comparator.comparingDouble(Material::getTarifaDiaria)).getTitol());

System.out.println("--- Top 2 per tarifa ---");
c.topN(2, CatalegOrdenable.Ordres.PER_TARIFA_DESC)
 .forEach(m -> System.out.println("  " + m.getTitol()));

c.cercarBinari("Java Eficac");
c.cercarBinari("Codi Net");

package com.nexussoftware.bibliotech.presentacio;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.TreeSet;

public class DemostracioOrdre {

    record FitxaSimple(String titol, String autor, int any) { }

    /** Ordre natural INCOHERENT amb equals: nomes mira l'any. */
    record FitxaPerAny(String titol, String autor, int any)
            implements Comparable<FitxaPerAny> {
        @Override public int compareTo(FitxaPerAny o) { return Integer.compare(any, o.any); }
    }

    public static void main(String[] args) {
        desbordament();
        truncament();
        incoherencia();
        estabilitat();
        reversedMalCollocat();
        binarySearchDesordenat();
    }

    static void desbordament() {
        System.out.println("=== 1. Restar enters DESBORDA ===");
        int a = 2_000_000_000, b = -2_000_000_000;

        System.out.println("a = " + a + ", b = " + b + "  -> a es clarament MES GRAN");
        System.out.println("a - b               = " + (a - b) + "   <- NEGATIU: diu a < b");
        System.out.println("Integer.compare(a,b)= " + Integer.compare(a, b) + "   <- correcte");
        System.out.println("Causa: 4.000.000.000 no cap en un int (max 2.147.483.647),");
        System.out.println("el valor fa la volta i canvia de signe. No restis mai.\n");
    }

    static void truncament() {
        System.out.println("=== 2. Restar dobles i fer casting TRUNCA ===");
        double llibre = 0.25, revista = 0.10, dvd = 0.50;

        System.out.println("(int)(dvd - revista)      = " + (int)(dvd - revista)
                           + "   <- 0.40 truncat a 0: 'son iguals'");
        System.out.println("(int)(llibre - revista)   = " + (int)(llibre - revista) + "   <- idem");
        System.out.println("Double.compare(dvd,revista)= " + Double.compare(dvd, revista));
        System.out.println("Amb aquest bug, TOTES les tarifes de BiblioTech serien iguals");
        System.out.println("i el cataleg no s'ordenaria en absolut.\n");
    }

    static void incoherencia() {
        System.out.println("=== 3. Ordre incoherent amb equals ===");
        FitxaPerAny a = new FitxaPerAny("Java Eficac",        "Joshua Bloch", 2018);
        FitxaPerAny b = new FitxaPerAny("Patrons de Disseny", "Erich Gamma",  2018);

        System.out.println("a.equals(b):    " + a.equals(b)    + "   <- son DIFERENTS");
        System.out.println("a.compareTo(b): " + a.compareTo(b) + "   <- pero EMPATEN");

        System.out.println("En List:     " + new ArrayList<>(List.of(a, b)).size() + " elements");
        System.out.println("En HashSet:  " + new HashSet<>(List.of(a, b)).size()
                           + " elements   <- usa equals/hashCode: correcte");
        System.out.println("En TreeSet:  " + new TreeSet<>(List.of(a, b)).size()
                           + " elements   <- usa compareTo: SE'N PERD UNA");

        Set<FitxaPerAny> arreglat = new TreeSet<>(
            Comparator.comparingInt(FitxaPerAny::any)
                      .thenComparing(FitxaPerAny::titol));     // desempat
        arreglat.addAll(List.of(a, b));
        System.out.println("Amb desempat: " + arreglat.size() + " elements   <- arreglat\n");
    }

    static void estabilitat() {
        System.out.println("=== 4. L'ordenacio de Java es ESTABLE ===");
        List<FitxaSimple> fitxes = new ArrayList<>(List.of(
            new FitxaSimple("Refactoritzacio",    "Martin Fowler", 1999),
            new FitxaSimple("Codi Net",           "Robert Martin", 2008),
            new FitxaSimple("Java Eficac",        "Joshua Bloch",  2018),
            new FitxaSimple("Java Concurrent",    "Brian Goetz",   2018),
            new FitxaSimple("Patrons de Disseny", "Erich Gamma",   1999)));

        fitxes.sort(Comparator.comparing(FitxaSimple::autor));       // criteri SECUNDARI
        System.out.println("Despres d'ordenar per autor:");
        fitxes.forEach(f -> System.out.printf("  %-16s %d  %s%n", f.autor(), f.any(), f.titol()));

        fitxes.sort(Comparator.comparingInt(FitxaSimple::any));      // criteri PRIMARI
        System.out.println("Despres d'ordenar per any (dins de cada any, continua per autor):");
        fitxes.forEach(f -> System.out.printf("  %-16s %d  %s%n", f.autor(), f.any(), f.titol()));

        System.out.println("Prefereix el comparador compost: UNA passada i mes clar:");
        fitxes.sort(Comparator.comparingInt(FitxaSimple::any)
                              .thenComparing(FitxaSimple::autor));
        System.out.println();
    }

    static void reversedMalCollocat() {
        System.out.println("=== 5. On collocar reversed() ===");
        List<FitxaSimple> fitxes = new ArrayList<>(List.of(
            new FitxaSimple("Java Eficac",      "Joshua Bloch", 2018),
            new FitxaSimple("Java Concurrent",  "Brian Goetz",  2018),
            new FitxaSimple("Refactoritzacio",  "Martin Fowler", 1999)));

        List<FitxaSimple> malament = new ArrayList<>(fitxes);
        malament.sort(Comparator.comparingInt(FitxaSimple::any)
                                .thenComparing(FitxaSimple::autor)
                                .reversed());     // inverteix ANY I AUTOR
        System.out.println("Amb .reversed() al final (inverteix TOTS DOS):");
        malament.forEach(f -> System.out.printf("  %d %s%n", f.any(), f.autor()));

        List<FitxaSimple> be = new ArrayList<>(fitxes);
        be.sort(Comparator.comparingInt(FitxaSimple::any).reversed()
                          .thenComparing(FitxaSimple::autor));    // nomes l'any
        System.out.println("Amb .reversed() despres de l'any (nomes inverteix l'any):");
        be.forEach(f -> System.out.printf("  %d %s%n", f.any(), f.autor()));
        System.out.println();
    }

    static void binarySearchDesordenat() {
        System.out.println("=== 6. binarySearch sobre llista DESORDENADA ===");
        List<Integer> desordenada = new ArrayList<>(List.of(30, 10, 50, 20, 40));
        System.out.println("Llista: " + desordenada);
        System.out.println("binarySearch(50): " + java.util.Collections.binarySearch(desordenada, 50)
                           + "   <- el 50 ES a l'index 2, pero retorna un negatiu");

        List<Integer> ordenada = new ArrayList<>(desordenada);
        java.util.Collections.sort(ordenada);
        System.out.println("Ordenada: " + ordenada);
        System.out.println("binarySearch(50): " + java.util.Collections.binarySearch(ordenada, 50)
                           + "   <- correcte");
        System.out.println("binarySearch(35): " + java.util.Collections.binarySearch(ordenada, 35)
                           + "   <- -(punt d'insercio) - 1 = -(3) - 1");
        System.out.println("Punt d'insercio: "
                           + (-java.util.Collections.binarySearch(ordenada, 35) - 1));
    }
}

package com.nexussoftware.bibliotech.presentacio;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import com.nexussoftware.bibliotech.domini.Llibre;
import com.nexussoftware.bibliotech.domini.Material;

/**
 * Compara quatre estrategies de cerca per referencia.
 *
 * ADVERTIMENT: no es un benchmark rigoros. El JIT compila sobre la marxa,
 * el recollidor pot intervenir i el compilador pot eliminar codi el resultat
 * del qual no es faci servir. Per mesurar de debo, JMH (05-04). Aquestes xifres
 * nomes serveixen per veure ORDRES DE MAGNITUD.
 */
public class ComparativaCerques {

    private static final int N       = 100_000;
    private static final int CERQUES = 10_000;
    private static long escut = 0;       // evita que el JIT elimini els bucles

    public static void main(String[] args) {
        List<Material> cataleg = generar(N);
        List<String>   claus   = clausAleatories(CERQUES);

        System.out.println("Escalfant la JVM...");
        for (int i = 0; i < 3; i++) {
            lineal(cataleg.subList(0, 1000), claus.subList(0, 100));
            ambHashMap(cataleg.subList(0, 1000), claus.subList(0, 100));
        }

        System.out.printf("%n=== %d materials, %d cerques ===%n", N, CERQUES);
        System.out.printf("%-24s %12s %12s %12s%n",
                          "Estrategia", "Preparar", "Cercar", "TOTAL");
        System.out.println("-".repeat(64));

        long[] r1 = lineal(cataleg, claus);
        long[] r2 = ambBinaria(cataleg, claus);
        long[] r3 = ambHashMap(cataleg, claus);
        long[] r4 = ambTreeMap(cataleg, claus);

        fila("1. Lineal (for + equals)",  r1);
        fila("2. Ordenar + binarySearch", r2);
        fila("3. HashMap",                r3);
        fila("4. TreeMap",                r4);

        System.out.println("\n(escut = " + escut + ", ignora'l)");
        conclusio();
    }

    private static void fila(String etiqueta, long[] t) {
        System.out.printf("%-24s %9d ms %9d ms %9d ms%n", etiqueta, t[0], t[1], t[0] + t[1]);
    }

    /** 1. Lineal: sense preparacio, O(n) per cerca. */
    private static long[] lineal(List<Material> cataleg, List<String> claus) {
        long t = System.nanoTime();
        int trobats = 0;
        for (String clau : claus) {
            for (Material m : cataleg) {
                if (m.getReferencia().equals(clau)) { trobats++; break; }
            }
        }
        escut += trobats;
        return new long[]{ 0, ms(t) };
    }

    /** 2. Ordenar una vegada O(n log n), despres O(log n) per cerca. */
    private static long[] ambBinaria(List<Material> cataleg, List<String> claus) {
        Comparator<Material> perReferencia = Comparator.comparing(Material::getReferencia);

        long t1 = System.nanoTime();
        List<Material> ordenat = new ArrayList<>(cataleg);
        ordenat.sort(perReferencia);
        long preparar = ms(t1);

        long t2 = System.nanoTime();
        int trobats = 0;
        for (String clau : claus) {
            // binarySearch necessita un ELEMENT: cal fabricar una sonda per cerca.
            // Aquest cost extra es real i penalitza aquesta estrategia.
            Material sonda = new Llibre("", "", clau, 2000);
            if (Collections.binarySearch(ordenat, sonda, perReferencia) >= 0) { trobats++; }
        }
        escut += trobats;
        return new long[]{ preparar, ms(t2) };
    }

    /** 3. Index hash: O(n) en construir, O(1) per cerca. */
    private static long[] ambHashMap(List<Material> cataleg, List<String> claus) {
        long t1 = System.nanoTime();
        Map<String, Material> index = new HashMap<>((int)(cataleg.size() / 0.75f) + 1);
        for (Material m : cataleg) { index.put(m.getReferencia(), m); }
        long preparar = ms(t1);

        long t2 = System.nanoTime();
        int trobats = 0;
        for (String clau : claus) {
            if (index.get(clau) != null) { trobats++; }
        }
        escut += trobats;
        return new long[]{ preparar, ms(t2) };
    }

    /** 4. Arbre: O(n log n) en construir, O(log n) per cerca, pero ORDENAT. */
    private static long[] ambTreeMap(List<Material> cataleg, List<String> claus) {
        long t1 = System.nanoTime();
        Map<String, Material> index = new TreeMap<>();
        for (Material m : cataleg) { index.put(m.getReferencia(), m); }
        long preparar = ms(t1);

        long t2 = System.nanoTime();
        int trobats = 0;
        for (String clau : claus) {
            if (index.get(clau) != null) { trobats++; }
        }
        escut += trobats;
        return new long[]{ preparar, ms(t2) };
    }

    private static List<Material> generar(int n) {
        List<Material> llista = new ArrayList<>(n);
        for (int i = 0; i < n; i++) {
            llista.add(new Llibre("Titol " + i, "Autor " + (i % 500),
                                  String.format("978-%010d", i), 1990 + (i % 35)));
        }
        return llista;
    }

    private static List<String> clausAleatories(int quantes) {
        List<String> claus = new ArrayList<>(quantes);
        java.util.Random atzar = new java.util.Random(42);   // llavor fixa: reproduible
        for (int i = 0; i < quantes; i++) {
            claus.add(String.format("978-%010d", atzar.nextInt(N)));
        }
        return claus;
    }

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

    private static void conclusio() {
        System.out.println("""

            === Conclusio ===
            1. LINEAL: zero preparacio, pero cada cerca recorre mitja llista.
               Amb 10.000 cerques sobre 100.000 elements son uns 500 milions
               de comparacions. Nomes val per a 1-2 cerques o llistes petites.

            2. ORDENAR + BINARIA: la preparacio es la mes cara (O(n log n)) i cada
               cerca es O(log n), unes 17 comparacions. A mes cal fabricar
               un element SONDA per cerca, cosa que penalitza forca.
               Val la pena quan a mes necessites la llista ordenada.

            3. HASHMAP: preparacio O(n) i cerca O(1). Es la mes rapida amb
               diferencia i la resposta per defecte per cercar per clau exacta.
               Preu: memoria extra i necessitar equals/hashCode correctes.

            4. TREEMAP: preparacio O(n log n) i cerca O(log n). Mes lent que
               el HashMap, pero a canvi mante les claus ORDENADES i ofereix
               firstKey, headMap, floorKey i consultes per rang.

            CRITERI:
              - Cerques 1-2 vegades  ............. lineal
              - Cerques per clau exacta, moltes .. HashMap
              - Necessites ordre o rangs ......... TreeMap
              - La llista ja esta ordenada ....... binarySearch
            """);
    }
}

=== 100000 materials, 10000 cerques ===
Estrategia                   Preparar       Cercar        TOTAL
----------------------------------------------------------------
1. Lineal (for + equals)         0 ms      2840 ms      2840 ms
2. Ordenar + binarySearch        95 ms        42 ms       137 ms
3. HashMap                      18 ms         2 ms        20 ms
4. TreeMap                      78 ms         9 ms        87 ms