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

    private static final int DEFAULT_CAPACITY = 10;

    transient Object[] elementData;   // el array interno donde viven los elementos
    private int size;                 // cuantos elementos hay REALMENTE
}

List<String> nombres = new ArrayList<>();
System.out.println(nombres.size());       // 0  (capacidad interna: 10 en cuanto anadas el primero)
nombres.add("Marta Ruiz");
nombres.add("Diego Alonso");
System.out.println(nombres.size());       // 2

ArrayList<Material> lista = new ArrayList<>(1000);
// ... solo se llenan 30 ...
lista.trimToSize();      // reduce la capacidad interna a 30

// dentro de ArrayList, simplificado:
private Object[] grow(int minCapacity) {
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);   // capacidad * 1.5
    return elementData = Arrays.copyOf(elementData, newCapacity);
}

List<Material> a = new ArrayList<>();                    // capacidad por defecto (10 al llenar)
List<Material> b = new ArrayList<>(500);                 // capacidad inicial 500
List<Material> c = new ArrayList<>(otraColeccion);       // copia con el tamano justo

// Cargar el catalogo completo: sabemos que son unos 5000 materiales
List<Material> catalogo = new ArrayList<>(5000);
for (String linea : lineasDelFichero) {
    catalogo.add(convertir(linea));
}

List<Material> copiaIndependiente = new ArrayList<>(catalogo);   // copia superficial modificable
List<String>   deUnSet            = new ArrayList<>(conjuntoISBN);
List<String>   deUnaListaFija     = new ArrayList<>(List.of("a", "b", "c"));  // ahora si es modificable

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

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

catalogo.add(new Libro("Java Efectivo",      "Joshua Bloch",  "978-0000000001", 2018));
catalogo.add(new Libro("Patrones de Diseno", "Erich Gamma",   "978-0000000002", 1994));
catalogo.add(new Libro("Refactorizacion",    "Martin Fowler", "978-0000000003", 1999));
catalogo.add(new Revista("Java Magazine",    "REV-2024-03",   42, "Mensual"));
catalogo.add(new Dvd("Refactorizacion en vivo", "DVD-0007",   95));

// Lista MODIFICABLE a partir de elementos sueltos
List<String> empleados = new ArrayList<>(List.of("Marta Ruiz", "Diego Alonso", "Nuria Vidal"));

// Lista INMUTABLE (cuidado: add lanzara UnsupportedOperationException)
List<String> fijos = List.of("Marta Ruiz", "Diego Alonso", "Nuria Vidal");

// Anadir varios de golpe a una lista existente
catalogo.addAll(otrosMateriales);
Collections.addAll(catalogo, material1, material2, material3);

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

l.add("D");                 // [A, B, C, D]   al final, O(1) amortizado
l.add(1, "X");              // [A, X, B, C, D] en la posicion 1, O(n): desplaza el resto
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 primero = l.get(0);          // O(1)
String ultimo  = l.get(l.size()-1); // el idioma para el ultimo elemento

String anterior = l.set(1, "Y");    // SUSTITUYE y devuelve lo que habia. O(1)

l.remove(0);                  // por INDICE, devuelve el elemento eliminado
l.remove("B");                // por OBJETO, devuelve boolean. Usa equals
l.removeIf(s -> s.isEmpty()); // por CRITERIO, devuelve boolean
l.clear();                    // vacia la lista

boolean hay = l.contains("C");       // O(n), usa equals
int pos     = l.indexOf("C");        // primera aparicion, o -1 si no esta. O(n)
int ultima  = l.lastIndexOf("C");    // ultima aparicion

class MaterialSinEquals { /* no sobrescribe equals */ }

List<Ficha> fichas = new ArrayList<>();
fichas.add(new Ficha("Java Efectivo", "Joshua Bloch", 2018));

// Ficha es un record: equals generado, compara componentes
System.out.println(fichas.contains(new Ficha("Java Efectivo", "Joshua Bloch", 2018)));  // true

// Si Ficha fuera una clase normal sin equals:
// System.out.println(...) -> false, aunque los datos sean identicos

l.replaceAll(String::toUpperCase);              // aplica una UnaryOperator a cada elemento
l.sort(Comparator.naturalOrder());              // ordena en el sitio
l.sort(Comparator.comparing(Material::getTitulo));
l.forEach(System.out::println);                 // recorre aplicando un Consumer

List<Material> catalogo = ...;
catalogo.sort(Comparator.comparing(Material::getTipo)
                        .thenComparing(Material::getTitulo));

int n         = l.size();
boolean vacia = l.isEmpty();       // preferible a size() == 0: mas legible

E       remove(int index);       // elimina por POSICION
boolean remove(Object o);        // elimina por VALOR

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

numeros.remove(1);                  // que elimina?
System.out.println(numeros);        // [10, 30, 40]  <- elimino la POSICION 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> numeros = new ArrayList<>(List.of(10, 20, 30, 40));

numeros.remove(Integer.valueOf(20));    // 1. explicito: por VALOR
numeros.remove((Integer) 30);           // 2. casting: por VALOR
numeros.remove(1);                      // 3. por POSICION (queda claro que es lo que quieres)

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

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

centro.clear();
System.out.println(l);         // [A, E]            <- se han borrado de la ORIGINAL

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

List<String> copiaDelCentro = new ArrayList<>(l.subList(1, 4));   // ahora si es independiente

// Paginar resultados sin copiar la lista entera
int desde = pagina * porPagina;
int hasta = Math.min(desde + porPagina, resultados.size());
List<Material> paginaActual = resultados.subList(desde, hasta);

// Borrar un rango completo
catalogo.subList(0, 10).clear();          // elimina los 10 primeros

// Ordenar solo un tramo
catalogo.subList(0, 5).sort(Comparator.comparing(Material::getTitulo));

// 1. for-each: por defecto, cuando solo lees
for (Material m : catalogo) {
    System.out.println(m.describir());
}

// 2. for clasico con indice: cuando necesitas la posicion o escribes con set
for (int i = 0; i < catalogo.size(); i++) {
    System.out.printf("%2d. %s%n", i + 1, catalogo.get(i).getTitulo());
}

// 3. forEach con Consumer: cuando ya tienes la accion como referencia a metodo
catalogo.forEach(System.out::println);

// CORRECTO Y PREFERIDO: una linea
catalogo.removeIf(m -> !m.estaDisponible());

// CORRECTO: iterador explicito, cuando la logica es compleja
Iterator<Material> it = catalogo.iterator();
while (it.hasNext()) {
    Material m = it.next();
    if (!m.estaDisponible()) {
        registrarBaja(m);        // efecto colateral antes de borrar
        it.remove();
    }
}

// CORRECTO: for clasico HACIA ATRAS, cuando necesitas el indice
for (int i = catalogo.size() - 1; i >= 0; i--) {
    if (!catalogo.get(i).estaDisponible()) {
        System.out.println("Baja en la posicion " + i);
        catalogo.remove(i);
    }
}

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

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

Material[] array = lista.toArray(new Material[0]);   // EL IDIOMA CORRECTO
Object[]   malo  = lista.toArray();                  // pierde el tipo: casi nunca util

Material[] array = { libro1, libro2, libro3 };

// 1. VISTA de tamano fijo respaldada por el array (05-01)
List<Material> vista = Arrays.asList(array);
vista.set(0, otro);        // OK, y modifica array[0]
// vista.add(otro);        // UnsupportedOperationException

// 2. Lista MODIFICABLE e INDEPENDIENTE  <- lo que quieres casi siempre
List<Material> modificable = new ArrayList<>(Arrays.asList(array));
modificable.add(otro);     // OK, y no toca 'array'

// 3. Lista INMUTABLE e independiente (Java 9+)
List<Material> inmutable = List.of(array);
// inmutable.set(0, otro); // UnsupportedOperationException

int[] primitivos = { 1, 2, 3 };
List<int[]> mal = Arrays.asList(primitivos);      // UNA lista de UN elemento (el array entero)
System.out.println(mal.size());                   // 1

Integer[] envueltos = { 1, 2, 3 };
List<Integer> bien = Arrays.asList(envueltos);    // 3 elementos, como esperabas
System.out.println(bien.size());                  // 3

List<Integer> lista = new ArrayList<>(primitivos.length);
for (int n : primitivos) { lista.add(n); }        // autoboxing en cada add

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

List<Material> libros = new ArrayList<>();
libros.add(new Libro("Java Efectivo", "Joshua Bloch", "978-0000000001", 2018));
libros.add(new Libro("Refactorizacion", "Martin Fowler", "978-0000000003", 1999));

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

porTipo.add(libros);
porTipo.add(revistas);
porTipo.add(new ArrayList<>());     // los DVD, todavia sin ninguno

// Acceso: dos indices, igual que en un array bidimensional
System.out.println(porTipo.get(0).get(1).getTitulo());   // Refactorizacion

// Recorrido anidado
for (List<Material> grupo : porTipo) {
    System.out.println("Grupo de " + grupo.size() + " materiales:");
    for (Material m : grupo) {
        System.out.println("   " + m.getTitulo());
    }
}

List<List<String>> matriz = new ArrayList<>();
for (int i = 0; i < 3; i++) {
    matriz.add(new ArrayList<>());       // cada fila necesita SU PROPIA lista
}
matriz.get(0).add("dato");               // ahora 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 implementacion NO importa
System.out.println(a.equals(c));      // false <- el ORDEN si importa
System.out.println(a.hashCode() == b.hashCode());   // true

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

/** Version del modulo 4, con Material[] y contador manual. */
public Material[] buscarPorTipo(String tipo) {
    Material[] resultado = new Material[n];      // hay que reservar el MAXIMO posible
    int encontrados = 0;
    for (int i = 0; i < n; i++) {                // hasta n, no hasta materiales.length
        if (materiales[i] != null && materiales[i].getTipo().equals(tipo)) {
            resultado[encontrados] = materiales[i];
            encontrados++;
        }
    }
    return Arrays.copyOf(resultado, encontrados);  // y recortar al final
}

/** Version del modulo 5. */
public List<Material> buscarPorTipo(String tipo) {
    List<Material> resultado = new ArrayList<>();
    for (Material m : materiales) {
        if (m.getTipo().equals(tipo)) { resultado.add(m); }
    }
    return resultado;
}

public List<Material> buscar(Predicate<Material> criterio) {
    List<Material> resultado = new ArrayList<>();
    for (Material m : materiales) {
        if (criterio.test(m)) { resultado.add(m); }
    }
    return resultado;
}

package com.nexussoftware.bibliotech.servicio;

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.dominio.Material;

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

    private final List<Material> materiales;
    private final Set<String>    referencias = new HashSet<>();   // unicidad en O(1)

    public Catalogo() {
        this.materiales = new ArrayList<>();
    }

    /** Capacidad inicial: util solo cuando cargamos un catalogo grande de golpe. */
    public Catalogo(int materialesPrevistos) {
        this.materiales = new ArrayList<>(Math.max(materialesPrevistos, 10));
    }

    public boolean anadir(Material m) {
        if (m == null) { return false; }
        if (!referencias.add(m.getReferencia())) {
            return false;                             // referencia duplicada
        }
        return materiales.add(m);                     // siempre true en una List
    }

    /** Inserta en una posicion concreta. O(n): desplaza el resto. */
    public boolean insertar(int posicion, Material m) {
        if (m == null || posicion < 0 || posicion > materiales.size()) { return false; }
        if (!referencias.add(m.getReferencia())) { return false; }
        materiales.add(posicion, m);
        return true;
    }

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

    /** Sustituye el material de una posicion conservando el tamano. */
    public Material reemplazar(int posicion, Material nuevo) {
        Material anterior = materiales.set(posicion, nuevo);   // devuelve el que habia
        referencias.remove(anterior.getReferencia());
        referencias.add(nuevo.getReferencia());
        return anterior;
    }

    public Material obtener(int posicion)  { return materiales.get(posicion); }   // O(1)
    public boolean  contiene(Material m)   { return materiales.contains(m); }     // O(n), usa equals
    public int      posicionDe(Material m) { return materiales.indexOf(m); }      // O(n)

    public List<Material> buscar(Predicate<Material> criterio) {
        List<Material> resultado = new ArrayList<>();
        for (Material m : materiales) {
            if (criterio.test(m)) { resultado.add(m); }
        }
        return resultado;
    }

    public int contar(Predicate<Material> criterio) {
        int n = 0;
        for (Material m : materiales) {
            if (criterio.test(m)) { n++; }
        }
        return n;
    }

    public void ordenar(Comparator<Material> criterio) { materiales.sort(criterio); }

    /** Pagina de resultados usando subList, con los limites bien controlados. */
    public List<Material> pagina(int numeroPagina, int porPagina) {
        int desde = numeroPagina * porPagina;
        if (desde >= materiales.size() || desde < 0) { return List.of(); }
        int hasta = Math.min(desde + porPagina, materiales.size());
        return new ArrayList<>(materiales.subList(desde, hasta));   // COPIA, no vista
    }

    /** Copia inmutable: nadie de fuera puede alterar el catalogo. */
    public List<Material> listar()   { return List.copyOf(materiales); }

    /** Cuando una API antigua pide un array. */
    public Material[] comoArray()    { return materiales.toArray(new Material[0]); }

    public int     tamano()  { return materiales.size(); }
    public boolean vacio()   { return materiales.isEmpty(); }
    public void    vaciar()  { materiales.clear(); referencias.clear(); }
}

Catalogo catalogo = new Catalogo();
catalogo.anadir(new Libro("Java Efectivo",      "Joshua Bloch",  "978-0000000001", 2018));
catalogo.anadir(new Libro("Patrones de Diseno", "Erich Gamma",   "978-0000000002", 1994));
catalogo.anadir(new Libro("Refactorizacion",    "Martin Fowler", "978-0000000003", 1999));
catalogo.anadir(new Revista("Java Magazine",    "REV-2024-03",   42, "Mensual"));
catalogo.anadir(new Dvd("Refactorizacion en vivo", "DVD-0007",   95));

catalogo.ordenar(Comparator.comparing(Material::getTipo)
                           .thenComparing(Material::getTitulo));

System.out.println("--- Catalogo (" + catalogo.tamano() + " materiales) ---");
catalogo.listar().forEach(m -> System.out.println("  " + m.describir()));

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

System.out.println("Pagina 0 (2 por pagina):");
catalogo.pagina(0, 2).forEach(m -> System.out.println("  " + m.getTitulo()));

--- Catalogo (5 materiales) ---
  [DVD] Refactorizacion en vivo (DVD-0007)
  [Libro] Java Efectivo - Joshua Bloch (978-0000000001)
  [Libro] Patrones de Diseno - Erich Gamma (978-0000000002)
  [Libro] Refactorizacion - Martin Fowler (978-0000000003)
  [Revista] Java Magazine num. 42 (REV-2024-03)
Tarifa inferior a 0,30 EUR/dia: 4
Pagina 0 (2 por pagina):
  Refactorizacion en vivo
  Java Efectivo

package com.nexussoftware.bibliotech.servicio;

import java.util.ArrayList;
import java.util.List;
import com.nexussoftware.bibliotech.dominio.Prestamo;

public class GestorPrestamos {

    private final List<Prestamo> prestamos = new ArrayList<>();

    public void registrar(Prestamo p) {
        if (p != null) { prestamos.add(p); }        // add al final: O(1) amortizado
    }

    /**
     * Busqueda lineal O(n) por referencia. Con muchos prestamos habria que
     * indexar por referencia en un Map<String, Prestamo>: eso es 05-05.
     */
    public boolean devolver(String referencia, int dia) {
        if (referencia == null) { return false; }
        for (Prestamo p : prestamos) {              // for-each: solo leemos
            if (referencia.equals(p.getReferencia())) {
                p.registrarDevolucion(dia);         // modificamos el OBJETO, no la lista: legal
                return true;
            }
        }
        return false;
    }

    public List<Prestamo> vencidos(int diaActual) {
        List<Prestamo> resultado = new ArrayList<>();
        for (Prestamo p : prestamos) {
            if (!p.estaDevuelto() && p.estaVencido(diaActual)) {
                resultado.add(p);
            }
        }
        return resultado;              // lista vacia si no hay ninguno, NUNCA null
    }

    /**
     * removeIf hace una sola pasada O(n). Un bucle con remove(Object)
     * seria O(n^2) y ademas daria ConcurrentModificationException.
     */
    public int purgarDevueltos() {
        int antes = prestamos.size();
        prestamos.removeIf(Prestamo::estaDevuelto);   // referencia a metodo (04-06)
        return antes - prestamos.size();
    }

    public List<Prestamo> ultimos(int cuantos) {
        if (cuantos <= 0 || prestamos.isEmpty()) { return List.of(); }
        int desde = Math.max(0, prestamos.size() - cuantos);   // proteccion del limite inferior
        // subList devuelve una VISTA: la copiamos para que sea independiente
        return new ArrayList<>(prestamos.subList(desde, prestamos.size()));
    }

    public Prestamo masAntiguo() {
        Prestamo mejor = null;
        for (Prestamo p : prestamos) {
            if (mejor == null || p.getDiaPrestamo() < mejor.getDiaPrestamo()) {
                mejor = p;
            }
        }
        return mejor;      // null si la lista esta vacia; documentalo en el javadoc
    }

    public int tamano() { return prestamos.size(); }
}

package com.nexussoftware.bibliotech.presentacion;

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

public class DemostracionRemove {

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

        // 1) remove(int): el literal 1 es un int -> se elige remove(int index)
        //    sin autoboxing, porque la sobrecarga prefiere la coincidencia exacta.
        numeros.remove(1);
        System.out.println("Tras remove(1):             " + numeros + "  <- borro la POSICION 1");

        // 2) remove(Object): Integer.valueOf(30) es un Integer -> remove(Object)
        numeros.remove(Integer.valueOf(30));
        System.out.println("Tras remove(valueOf(30)):   " + numeros + "  <- borro el VALOR 30");

        // 3) El casting produce el mismo efecto que valueOf, pero se lee peor
        numeros.remove((Integer) 40);
        System.out.println("Tras remove((Integer) 40):  " + numeros + "  <- borro el VALOR 40");

        // 4) La llamada peligrosa, comentada a proposito:
        // numeros.remove(100);
        //    -> IndexOutOfBoundsException: Index 100 out of bounds for length 2
        //    El programador queria borrar el VALOR 100 y ha pedido la POSICION 100.
        //    El error se descubre en ejecucion, no al compilar.

        // 5) Con String no hay ambiguedad: "Marta Ruiz" no es un int,
        //    asi que solo puede resolverse como remove(Object).
        List<String> empleados = new ArrayList<>(List.of("Marta Ruiz", "Diego Alonso"));
        empleados.remove("Marta Ruiz");
        System.out.println("Empleados:                  " + empleados);

        // 6) Metodo seguro y reutilizable
        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 por VALOR sin ambiguedad posible. El parametro es int por comodidad
     * de quien llama, y el envoltorio explicito garantiza que se invoque
     * remove(Object) y no remove(int).
     */
    public static boolean eliminarValor(List<Integer> lista, int valor) {
        return lista.remove(Integer.valueOf(valor));
    }
}

Inicial:                    [10, 20, 30, 40, 50]
Tras remove(1):             [10, 30, 40, 50]  <- borro la POSICION 1
Tras remove(valueOf(30)):   [10, 40, 50]  <- borro el VALOR 30
Tras remove((Integer) 40):  [10, 50]  <- borro el VALOR 40
Empleados:                  [Diego Alonso]
eliminarValor(205): true -> [101, 307]
eliminarValor(999): false -> [101, 307]

package com.nexussoftware.bibliotech.presentacion;

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

public final class ConversorColecciones {

    private ConversorColecciones() { }

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

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

        array[1] = "Diego A.";                            // por el otro lado
        System.out.println("vista tras array[1]=:    " + vista);      // Diego A.

        // vista.add("Nuevo");    -> UnsupportedOperationException: tamano FIJO
        // vista.remove(0);       -> UnsupportedOperationException
        System.out.println("add y remove lanzarian UnsupportedOperationException");
    }

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

        copia.add("Nuria Vidal");        // ahora si se puede
        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("El array original NO se ha visto afectado");
    }

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

        // new String[0] indica el TIPO. toArray crea internamente uno del tamano justo.
        String[] array = lista.toArray(new String[0]);
        System.out.println("array: " + Arrays.toString(array) + " (length " + array.length + ")");

        lista.add("Nuria Vidal");        // el array ya generado no cambia
        System.out.println("tras anadir a la lista, array sigue con " + array.length);

        Object[] sinTipo = lista.toArray();     // pierde el tipo: casi nunca util
        System.out.println("toArray() sin argumento devuelve Object[]: " + sinTipo.length);
    }

    public static void demostrarPrimitivos() {
        System.out.println("--- La trampa de los primitivos ---");
        int[] primitivos = { 1, 2, 3 };
        List<int[]> mal = Arrays.asList(primitivos);
        System.out.println("Arrays.asList(int[]).size()     = " + mal.size()
                           + "   <- UNA lista de UN elemento: el array entero");

        Integer[] envueltos = { 1, 2, 3 };
        List<Integer> bien = Arrays.asList(envueltos);
        System.out.println("Arrays.asList(Integer[]).size() = " + bien.size()
                           + "   <- tres elementos, como esperabas");
        System.out.println("Causa: los genericos solo admiten tipos referencia (10-01)");
    }

    /** Conversion correcta de int[] a List<Integer>. */
    public static List<Integer> aLista(int[] primitivos) {
        if (primitivos == null) { return List.of(); }
        // capacidad inicial exacta: sabemos cuantos van a entrar
        List<Integer> lista = new ArrayList<>(primitivos.length);
        for (int n : primitivos) {
            lista.add(n);                 // autoboxing: int -> Integer en cada add
        }
        return lista;
    }

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