public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess {

    private static final int DEFAULT_CAPACITY = 10;

    transient Object[] elementData;   // l'array intern on viuen els elements
    private int size;                 // quants elements hi ha REALMENT
}

List<String> noms = new ArrayList<>();
System.out.println(noms.size());          // 0  (capacitat interna: 10 en quant afegeixis el primer)
noms.add("Marta Ruiz");
noms.add("Diego Alonso");
System.out.println(noms.size());          // 2

ArrayList<Material> llista = new ArrayList<>(1000);
// ... nomes se n'omplen 30 ...
llista.trimToSize();     // redueix la capacitat interna a 30

// dins d'ArrayList, simplificat:
private Object[] grow(int minCapacity) {
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);   // capacitat * 1.5
    return elementData = Arrays.copyOf(elementData, newCapacity);
}

List<Material> a = new ArrayList<>();                    // capacitat per defecte (10 en omplir)
List<Material> b = new ArrayList<>(500);                 // capacitat inicial 500
List<Material> c = new ArrayList<>(altraColleccio);      // copia amb la mida justa

// Carregar el cataleg complet: sabem que son uns 5000 materials
List<Material> cataleg = new ArrayList<>(5000);
for (String linia : liniesDelFitxer) {
    cataleg.add(convertir(linia));
}

List<Material> copiaIndependent = new ArrayList<>(cataleg);   // copia superficial modificable
List<String>   dUnSet           = new ArrayList<>(conjuntISBN);
List<String>   dUnaLlistaFixa   = new ArrayList<>(List.of("a", "b", "c"));  // ara si es modificable

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

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

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

// Llista MODIFICABLE a partir d'elements solts
List<String> empleats = new ArrayList<>(List.of("Marta Ruiz", "Diego Alonso", "Nuria Vidal"));

// Llista IMMUTABLE (compte: add llancara UnsupportedOperationException)
List<String> fixos = List.of("Marta Ruiz", "Diego Alonso", "Nuria Vidal");

// Afegir-ne diversos de cop a una llista existent
cataleg.addAll(altresMaterials);
Collections.addAll(cataleg, material1, material2, material3);

List<String> l = new ArrayList<>(List.of("A", "B", "C"));

l.add("D");                 // [A, B, C, D]   al final, O(1) amortitzat
l.add(1, "X");              // [A, X, B, C, D] a la posicio 1, O(n): desplaca la resta
l.addAll(List.of("E","F")); // [A, X, B, C, D, E, F]
l.addAll(0, List.of("Z"));  // [Z, A, X, B, C, D, E, F]

String primer = l.get(0);           // O(1)
String ultim  = l.get(l.size()-1);  // l'idioma per a l'ultim element

String anterior = l.set(1, "Y");    // SUBSTITUEIX i retorna el que hi havia. O(1)

l.remove(0);                  // per INDEX, retorna l'element eliminat
l.remove("B");                // per OBJECTE, retorna boolean. Usa equals
l.removeIf(s -> s.isEmpty()); // per CRITERI, retorna boolean
l.clear();                    // buida la llista

boolean conte = l.contains("C");     // O(n), usa equals
int pos       = l.indexOf("C");      // primera aparicio, o -1 si no hi es. O(n)
int ultima    = l.lastIndexOf("C");  // ultima aparicio

class MaterialSenseEquals { /* no sobreescriu equals */ }

List<Fitxa> fitxes = new ArrayList<>();
fitxes.add(new Fitxa("Java Eficac", "Joshua Bloch", 2018));

// Fitxa es un record: equals generat, compara components
System.out.println(fitxes.contains(new Fitxa("Java Eficac", "Joshua Bloch", 2018)));  // true

// Si Fitxa fos una classe normal sense equals:
// System.out.println(...) -> false, encara que les dades siguin identiques

l.replaceAll(String::toUpperCase);              // aplica un UnaryOperator a cada element
l.sort(Comparator.naturalOrder());              // ordena al lloc
l.sort(Comparator.comparing(Material::getTitol));
l.forEach(System.out::println);                 // recorre aplicant un Consumer

List<Material> cataleg = ...;
cataleg.sort(Comparator.comparing(Material::getTipus)
                       .thenComparing(Material::getTitol));

int n         = l.size();
boolean buida = l.isEmpty();       // preferible a size() == 0: mes llegible

E       remove(int index);       // elimina per POSICIO
boolean remove(Object o);        // elimina per VALOR

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

nombres.remove(1);                  // que elimina?
System.out.println(nombres);        // [10, 30, 40]  <- he eliminat la POSICIO 1, no el valor 1

List<Integer> ids = new ArrayList<>(List.of(100, 200, 300));
ids.remove(100);         // IndexOutOfBoundsException: Index 100 out of bounds for length 3

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

nombres.remove(Integer.valueOf(20));    // 1. explicit: per VALOR
nombres.remove((Integer) 30);           // 2. casting: per VALOR
nombres.remove(1);                      // 3. per POSICIO (queda clar que es el que vols)

List<String> l = new ArrayList<>(List.of("A", "B", "C", "D", "E"));
List<String> centre = l.subList(1, 4);     // [B, C, D]

centre.set(0, "X");
System.out.println(l);         // [A, X, C, D, E]   <- ha canviat l'ORIGINAL

centre.clear();
System.out.println(l);         // [A, E]            <- s'han esborrat de l'ORIGINAL

List<String> l = new ArrayList<>(List.of("A", "B", "C", "D", "E"));
List<String> centre = l.subList(1, 4);
l.add("F");                          // modificacio estructural de l'original
System.out.println(centre);          // ConcurrentModificationException

List<String> copiaDelCentre = new ArrayList<>(l.subList(1, 4));   // ara si que es independent

// Paginar resultats sense copiar la llista sencera
int inici = pagina * perPagina;
int fi    = Math.min(inici + perPagina, resultats.size());
List<Material> paginaActual = resultats.subList(inici, fi);

// Esborrar un rang complet
cataleg.subList(0, 10).clear();           // elimina els 10 primers

// Ordenar nomes un tram
cataleg.subList(0, 5).sort(Comparator.comparing(Material::getTitol));

// 1. for-each: per defecte, quan nomes llegeixes
for (Material m : cataleg) {
    System.out.println(m.descriure());
}

// 2. for classic amb index: quan necessites la posicio o escrius amb set
for (int i = 0; i < cataleg.size(); i++) {
    System.out.printf("%2d. %s%n", i + 1, cataleg.get(i).getTitol());
}

// 3. forEach amb Consumer: quan ja tens l'accio com a referencia a metode
cataleg.forEach(System.out::println);

// CORRECTE I PREFERIT: una linia
cataleg.removeIf(m -> !m.estaDisponible());

// CORRECTE: iterador explicit, quan la logica es complexa
Iterator<Material> it = cataleg.iterator();
while (it.hasNext()) {
    Material m = it.next();
    if (!m.estaDisponible()) {
        registrarBaixa(m);       // efecte collateral abans d'esborrar
        it.remove();
    }
}

// CORRECTE: for classic CAP ENRERE, quan necessites l'index
for (int i = cataleg.size() - 1; i >= 0; i--) {
    if (!cataleg.get(i).estaDisponible()) {
        System.out.println("Baixa a la posicio " + i);
        cataleg.remove(i);
    }
}

// INCORRECTE: ConcurrentModificationException
for (Material m : cataleg) {
    if (!m.estaDisponible()) { cataleg.remove(m); }
}

List<Material> llista = new ArrayList<>(...);

Material[] array   = llista.toArray(new Material[0]);   // L'IDIOMA CORRECTE
Object[]   dolent  = llista.toArray();                  // perd el tipus: gairebe mai util

Material[] array = { llibre1, llibre2, llibre3 };

// 1. VISTA de mida fixa recolzada en l'array (05-01)
List<Material> vista = Arrays.asList(array);
vista.set(0, altre);       // OK, i modifica array[0]
// vista.add(altre);       // UnsupportedOperationException

// 2. Llista MODIFICABLE i INDEPENDENT  <- el que vols gairebe sempre
List<Material> modificable = new ArrayList<>(Arrays.asList(array));
modificable.add(altre);    // OK, i no toca 'array'

// 3. Llista IMMUTABLE i independent (Java 9+)
List<Material> immutable = List.of(array);
// immutable.set(0, altre); // UnsupportedOperationException

int[] primitius = { 1, 2, 3 };
List<int[]> malament = Arrays.asList(primitius);  // UNA llista d'UN element (l'array sencer)
System.out.println(malament.size());              // 1

Integer[] embolcallats = { 1, 2, 3 };
List<Integer> be = Arrays.asList(embolcallats);   // 3 elements, com esperaves
System.out.println(be.size());                    // 3

List<Integer> llista = new ArrayList<>(primitius.length);
for (int n : primitius) { llista.add(n); }        // autoboxing a cada add

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

List<Material> llibres = new ArrayList<>();
llibres.add(new Llibre("Java Eficac", "Joshua Bloch", "978-0000000001", 2018));
llibres.add(new Llibre("Refactoritzacio", "Martin Fowler", "978-0000000003", 1999));

List<Material> revistes = new ArrayList<>();
revistes.add(new Revista("Java Magazine", "REV-2024-03", 42, "Mensual"));

perTipus.add(llibres);
perTipus.add(revistes);
perTipus.add(new ArrayList<>());     // els DVD, encara sense cap

// Acces: dos indexs, igual que en un array bidimensional
System.out.println(perTipus.get(0).get(1).getTitol());   // Refactoritzacio

// Recorregut imbricat
for (List<Material> grup : perTipus) {
    System.out.println("Grup de " + grup.size() + " materials:");
    for (Material m : grup) {
        System.out.println("   " + m.getTitol());
    }
}

List<List<String>> matriu = new ArrayList<>();
for (int i = 0; i < 3; i++) {
    matriu.add(new ArrayList<>());       // cada fila necessita LA SEVA PROPIA llista
}
matriu.get(0).add("dada");               // ara si

List<String> a = new ArrayList<>(List.of("Marta Ruiz", "Diego Alonso"));
List<String> b = new LinkedList<>(List.of("Marta Ruiz", "Diego Alonso"));
List<String> c = new ArrayList<>(List.of("Diego Alonso", "Marta Ruiz"));

System.out.println(a.equals(b));      // true  <- la implementacio NO importa
System.out.println(a.equals(c));      // false <- l'ORDRE si que importa
System.out.println(a.hashCode() == b.hashCode());   // true

int hash = 1;
for (E e : llista) {
    hash = 31 * hash + (e == null ? 0 : e.hashCode());
}

/** Versio del modul 4, amb Material[] i comptador manual. */
public Material[] cercarPerTipus(String tipus) {
    Material[] resultat = new Material[n];       // cal reservar el MAXIM possible
    int trobats = 0;
    for (int i = 0; i < n; i++) {                // fins a n, no fins a materials.length
        if (materials[i] != null && materials[i].getTipus().equals(tipus)) {
            resultat[trobats] = materials[i];
            trobats++;
        }
    }
    return Arrays.copyOf(resultat, trobats);     // i retallar al final
}

/** Versio del modul 5. */
public List<Material> cercarPerTipus(String tipus) {
    List<Material> resultat = new ArrayList<>();
    for (Material m : materials) {
        if (m.getTipus().equals(tipus)) { resultat.add(m); }
    }
    return resultat;
}

public List<Material> cercar(Predicate<Material> criteri) {
    List<Material> resultat = new ArrayList<>();
    for (Material m : materials) {
        if (criteri.test(m)) { resultat.add(m); }
    }
    return resultat;
}

package com.nexussoftware.bibliotech.servei;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.function.Predicate;
import com.nexussoftware.bibliotech.domini.Material;

/** Cataleg de BiblioTech sobre ArrayList. */
public class Cataleg {

    private final List<Material> materials;
    private final Set<String>    referencies = new HashSet<>();   // unicitat en O(1)

    public Cataleg() {
        this.materials = new ArrayList<>();
    }

    /** Capacitat inicial: util nomes quan carreguem un cataleg gran de cop. */
    public Cataleg(int materialsPrevistos) {
        this.materials = new ArrayList<>(Math.max(materialsPrevistos, 10));
    }

    public boolean afegir(Material m) {
        if (m == null) { return false; }
        if (!referencies.add(m.getReferencia())) {
            return false;                             // referencia duplicada
        }
        return materials.add(m);                      // sempre true en una List
    }

    /** Insereix en una posicio concreta. O(n): desplaca la resta. */
    public boolean inserir(int posicio, Material m) {
        if (m == null || posicio < 0 || posicio > materials.size()) { return false; }
        if (!referencies.add(m.getReferencia())) { return false; }
        materials.add(posicio, m);
        return true;
    }

    public boolean eliminar(String referencia) {
        if (!referencies.remove(referencia)) { return false; }
        return materials.removeIf(m -> m.getReferencia().equals(referencia));
    }

    /** Substitueix el material d'una posicio conservant la mida. */
    public Material reemplacar(int posicio, Material nou) {
        Material anterior = materials.set(posicio, nou);   // retorna el que hi havia
        referencies.remove(anterior.getReferencia());
        referencies.add(nou.getReferencia());
        return anterior;
    }

    public Material obtenir(int posicio)   { return materials.get(posicio); }    // O(1)
    public boolean  conte(Material m)      { return materials.contains(m); }     // O(n), usa equals
    public int      posicioDe(Material m)  { return materials.indexOf(m); }      // O(n)

    public List<Material> cercar(Predicate<Material> criteri) {
        List<Material> resultat = new ArrayList<>();
        for (Material m : materials) {
            if (criteri.test(m)) { resultat.add(m); }
        }
        return resultat;
    }

    public int comptar(Predicate<Material> criteri) {
        int n = 0;
        for (Material m : materials) {
            if (criteri.test(m)) { n++; }
        }
        return n;
    }

    public void ordenar(Comparator<Material> criteri) { materials.sort(criteri); }

    /** Pagina de resultats fent servir subList, amb els limits ben controlats. */
    public List<Material> pagina(int numeroPagina, int perPagina) {
        int inici = numeroPagina * perPagina;
        if (inici >= materials.size() || inici < 0) { return List.of(); }
        int fi = Math.min(inici + perPagina, materials.size());
        return new ArrayList<>(materials.subList(inici, fi));   // COPIA, no vista
    }

    /** Copia immutable: ningu de fora no pot alterar el cataleg. */
    public List<Material> llistar()  { return List.copyOf(materials); }

    /** Quan una API antiga demana un array. */
    public Material[] comArray()     { return materials.toArray(new Material[0]); }

    public int     mida()   { return materials.size(); }
    public boolean buit()   { return materials.isEmpty(); }
    public void    buidar() { materials.clear(); referencies.clear(); }
}

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

cataleg.ordenar(Comparator.comparing(Material::getTipus)
                          .thenComparing(Material::getTitol));

System.out.println("--- Cataleg (" + cataleg.mida() + " materials) ---");
cataleg.llistar().forEach(m -> System.out.println("  " + m.descriure()));

List<Material> barats = cataleg.cercar(m -> m.getTarifaDiaria() < 0.30);
System.out.println("Tarifa inferior a 0,30 EUR/dia: " + barats.size());

System.out.println("Pagina 0 (2 per pagina):");
cataleg.pagina(0, 2).forEach(m -> System.out.println("  " + m.getTitol()));

--- Cataleg (5 materials) ---
  [DVD] Refactoritzacio en directe (DVD-0007)
  [Llibre] Java Eficac - Joshua Bloch (978-0000000001)
  [Llibre] Patrons de Disseny - Erich Gamma (978-0000000002)
  [Llibre] Refactoritzacio - Martin Fowler (978-0000000003)
  [Revista] Java Magazine num. 42 (REV-2024-03)
Tarifa inferior a 0,30 EUR/dia: 4
Pagina 0 (2 per pagina):
  Refactoritzacio en directe
  Java Eficac

package com.nexussoftware.bibliotech.servei;

import java.util.ArrayList;
import java.util.List;
import com.nexussoftware.bibliotech.domini.Prestec;

public class GestorPrestecs {

    private final List<Prestec> prestecs = new ArrayList<>();

    public void registrar(Prestec p) {
        if (p != null) { prestecs.add(p); }         // add al final: O(1) amortitzat
    }

    /**
     * Cerca lineal O(n) per referencia. Amb molts prestecs caldria
     * indexar per referencia en un Map<String, Prestec>: aixo es 05-05.
     */
    public boolean retornar(String referencia, int dia) {
        if (referencia == null) { return false; }
        for (Prestec p : prestecs) {                // for-each: nomes llegim
            if (referencia.equals(p.getReferencia())) {
                p.registrarDevolucio(dia);          // modifiquem l'OBJECTE, no la llista: legal
                return true;
            }
        }
        return false;
    }

    public List<Prestec> vencuts(int diaActual) {
        List<Prestec> resultat = new ArrayList<>();
        for (Prestec p : prestecs) {
            if (!p.estaRetornat() && p.estaVencut(diaActual)) {
                resultat.add(p);
            }
        }
        return resultat;               // llista buida si no n'hi ha cap, MAI null
    }

    /**
     * removeIf fa una sola passada O(n). Un bucle amb remove(Object)
     * seria O(n^2) i a mes donaria ConcurrentModificationException.
     */
    public int purgarRetornats() {
        int abans = prestecs.size();
        prestecs.removeIf(Prestec::estaRetornat);   // referencia a metode (04-06)
        return abans - prestecs.size();
    }

    public List<Prestec> ultims(int quants) {
        if (quants <= 0 || prestecs.isEmpty()) { return List.of(); }
        int inici = Math.max(0, prestecs.size() - quants);   // proteccio del limit inferior
        // subList retorna una VISTA: la copiem perque sigui independent
        return new ArrayList<>(prestecs.subList(inici, prestecs.size()));
    }

    public Prestec mesAntic() {
        Prestec millor = null;
        for (Prestec p : prestecs) {
            if (millor == null || p.getDiaPrestec() < millor.getDiaPrestec()) {
                millor = p;
            }
        }
        return millor;     // null si la llista es buida; documenta-ho al javadoc
    }

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

package com.nexussoftware.bibliotech.presentacio;

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

public class DemostracioRemove {

    public static void main(String[] args) {
        List<Integer> nombres = new ArrayList<>(List.of(10, 20, 30, 40, 50));
        System.out.println("Inicial:                          " + nombres);

        // 1) remove(int): el literal 1 es un int -> es tria remove(int index)
        //    sense autoboxing, perque la sobrecarrega prefereix la coincidencia exacta.
        nombres.remove(1);
        System.out.println("Despres de remove(1):             " + nombres + "  <- he esborrat la POSICIO 1");

        // 2) remove(Object): Integer.valueOf(30) es un Integer -> remove(Object)
        nombres.remove(Integer.valueOf(30));
        System.out.println("Despres de remove(valueOf(30)):   " + nombres + "  <- he esborrat el VALOR 30");

        // 3) El casting produeix el mateix efecte que valueOf, pero es llegeix pitjor
        nombres.remove((Integer) 40);
        System.out.println("Despres de remove((Integer) 40):  " + nombres + "  <- he esborrat el VALOR 40");

        // 4) La crida perillosa, comentada a proposit:
        // nombres.remove(100);
        //    -> IndexOutOfBoundsException: Index 100 out of bounds for length 2
        //    El programador volia esborrar el VALOR 100 i ha demanat la POSICIO 100.
        //    L'error es descobreix en execucio, no en compilar.

        // 5) Amb String no hi ha ambiguitat: "Marta Ruiz" no es un int,
        //    aixi que nomes es pot resoldre com a remove(Object).
        List<String> empleats = new ArrayList<>(List.of("Marta Ruiz", "Diego Alonso"));
        empleats.remove("Marta Ruiz");
        System.out.println("Empleats:                         " + empleats);

        // 6) Metode segur i reutilitzable
        List<Integer> ids = new ArrayList<>(List.of(101, 205, 307));
        System.out.println("eliminarValor(205): " + eliminarValor(ids, 205) + " -> " + ids);
        System.out.println("eliminarValor(999): " + eliminarValor(ids, 999) + " -> " + ids);
    }

    /**
     * Elimina per VALOR sense cap ambiguitat possible. El parametre es int per comoditat
     * de qui crida, i l'embolcall explicit garanteix que s'invoqui
     * remove(Object) i no remove(int).
     */
    public static boolean eliminarValor(List<Integer> llista, int valor) {
        return llista.remove(Integer.valueOf(valor));
    }
}

Inicial:                          [10, 20, 30, 40, 50]
Despres de remove(1):             [10, 30, 40, 50]  <- he esborrat la POSICIO 1
Despres de remove(valueOf(30)):   [10, 40, 50]  <- he esborrat el VALOR 30
Despres de remove((Integer) 40):  [10, 50]  <- he esborrat el VALOR 40
Empleats:                         [Diego Alonso]
eliminarValor(205): true -> [101, 307]
eliminarValor(999): false -> [101, 307]

package com.nexussoftware.bibliotech.presentacio;

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

public final class ConversorColleccions {

    private ConversorColleccions() { }

    public static void demostrarAsList() {
        System.out.println("--- Arrays.asList es una VISTA de mida fixa ---");
        String[] array = { "Marta Ruiz", "Diego Alonso", "Nuria Vidal" };
        List<String> vista = Arrays.asList(array);

        vista.set(0, "Marta R.");                        // permes
        System.out.println("array[0] despres de vista.set: " + array[0]);   // Marta R.

        array[1] = "Diego A.";                            // per l'altre costat
        System.out.println("vista despres de array[1]=:    " + vista);      // Diego A.

        // vista.add("Nou");      -> UnsupportedOperationException: mida FIXA
        // vista.remove(0);       -> UnsupportedOperationException
        System.out.println("add i remove llancarien UnsupportedOperationException");
    }

    public static void demostrarCopiaIndependent() {
        System.out.println("--- new ArrayList<>(Arrays.asList(a)) es INDEPENDENT ---");
        String[] array = { "Marta Ruiz", "Diego Alonso" };
        List<String> copia = new ArrayList<>(Arrays.asList(array));

        copia.add("Nuria Vidal");        // ara si que es pot
        copia.set(0, "Marta R.");

        System.out.println("copia:   " + copia);            // [Marta R., Diego Alonso, Nuria Vidal]
        System.out.println("array:   " + Arrays.toString(array));   // [Marta Ruiz, Diego Alonso]
        System.out.println("L'array original NO s'ha vist afectat");
    }

    public static void demostrarToArray() {
        System.out.println("--- De llista a array ---");
        List<String> llista = new ArrayList<>(List.of("Marta Ruiz", "Diego Alonso"));

        // new String[0] indica el TIPUS. toArray en crea internament un de la mida justa.
        String[] array = llista.toArray(new String[0]);
        System.out.println("array: " + Arrays.toString(array) + " (length " + array.length + ")");

        llista.add("Nuria Vidal");       // l'array ja generat no canvia
        System.out.println("despres d'afegir a la llista, array continua amb " + array.length);

        Object[] senseTipus = llista.toArray();    // perd el tipus: gairebe mai util
        System.out.println("toArray() sense argument retorna Object[]: " + senseTipus.length);
    }

    public static void demostrarPrimitius() {
        System.out.println("--- El parany dels primitius ---");
        int[] primitius = { 1, 2, 3 };
        List<int[]> malament = Arrays.asList(primitius);
        System.out.println("Arrays.asList(int[]).size()     = " + malament.size()
                           + "   <- UNA llista d'UN element: l'array sencer");

        Integer[] embolcallats = { 1, 2, 3 };
        List<Integer> be = Arrays.asList(embolcallats);
        System.out.println("Arrays.asList(Integer[]).size() = " + be.size()
                           + "   <- tres elements, com esperaves");
        System.out.println("Causa: els generics nomes admeten tipus referencia (10-01)");
    }

    /** Conversio correcta d'int[] a List<Integer>. */
    public static List<Integer> aLlista(int[] primitius) {
        if (primitius == null) { return List.of(); }
        // capacitat inicial exacta: sabem quants n'entraran
        List<Integer> llista = new ArrayList<>(primitius.length);
        for (int n : primitius) {
            llista.add(n);                // autoboxing: int -> Integer a cada add
        }
        return llista;
    }

    public static void main(String[] args) {
        demostrarAsList();
        demostrarCopiaIndependent();
        demostrarToArray();
        demostrarPrimitius();
        System.out.println("aLlista(new int[]{7,8,9}) = " + aLlista(new int[] { 7, 8, 9 }));
    }
}