Tema 7 - ArrayList – Tu Mochila Infinita en Java

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

public class CreacionListas {
    public static void main(String[] args) {

        // FORMA CLÁSICA (Antes de Java 7) - Muy verbosa
        // ArrayList<String> listaNombres = new ArrayList<String>();

        // FORMA ESTÁNDAR (Operador Diamond <>)
        // Recomendado: Usar la interfaz 'List' a la izquierda (Polimorfismo)
        List<String> estudiantes = new ArrayList<>();

        // FORMA JAVA 10+ (Inferencia de tipos con 'var')
        // El compilador deduce que es un ArrayList<String>
        var videojuegos = new ArrayList<String>();

        videojuegos.add("Elden Ring");
        videojuegos.add("Hollow Knight");

        System.out.println("Mis juegos: " + videojuegos);
    }
}

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

public class CreacionAvanzada {
    public static void main(String[] args) {

        // 1. Crear una lista inmutable (Java 9+)
        List<String> inmutable = List.of("HTML", "CSS", "JS");
        // inmutable.add("JAVA"); // ¡ERROR! Boom 💥

        // 2. Crear ArrayList mutable a partir de unos valores (TRUCO PRO)
        // Creamos un ArrayList nuevo y le volcamos el contenido de List.of
        List<String> tecnologiasWeb = new ArrayList<>(List.of("HTML", "CSS", "JS"));

        tecnologiasWeb.add("JAVA"); // ¡Ahora sí funciona!
        tecnologiasWeb.add("SQL");

        System.out.println("Stack Fullstack: " + tecnologiasWeb);
    }
}

var playlist = new ArrayList<String>();

// add(E e): Añade al final. Devuelve boolean (siempre true en ArrayList).
playlist.add("Bohemian Rhapsody"); 
playlist.add("Despacito");

// add(int index, E element): Inserta en una posición, desplazando el resto a la derecha.
playlist.add(0, "Imagine"); // Se pone la primera

// addAll(Collection<? extends E> c): Añade toda otra lista al final.
var rockClassics = List.of("Stairway to Heaven", "Hotel California");
boolean cambiado = playlist.addAll(rockClassics);

// addAll(int index, Collection c): Inserta una colección en una posición específica.
playlist.addAll(1, List.of("Song 2", "Wonderwall"));

System.out.println(playlist);

// size(): Devuelve el número de elementos (int).
System.out.println("Canciones totales: " + playlist.size());

// isEmpty(): Devuelve true si no hay elementos.
if (!playlist.isEmpty()) {
    System.out.println("¡A bailar!");
}

// contains(Object o): Busca si existe el elemento (usa equals()). Devuelve boolean.
// Es muy útil para evitar duplicados manuales.
if (playlist.contains("Despacito")) {
    System.out.println("Oh no, esa canción otra vez no...");
}

// get(int index): Devuelve el elemento en esa posición (T).
String primeraCancion = playlist.get(0);

// indexOf(Object o): Devuelve la posición de la PRIMERA aparición. -1 si no está.
int posImagine = playlist.indexOf("Imagine");

// lastIndexOf(Object o): Devuelve la posición de la ÚLTIMA aparición.
playlist.add("Imagine"); // La añadimos otra vez para probar
int ultimaPos = playlist.lastIndexOf("Imagine");

System.out.println("Primera aparición: " + posImagine + ", Última: " + ultimaPos);

import java.util.Comparator;

// set(int index, E element): Reemplaza el elemento en la posición. Devuelve el antiguo.
// Cambiamos "Despacito" (si estuviera en pos 2) por algo mejor.
playlist.set(2, "Thunderstruck");

// replaceAll(UnaryOperator<E> operator): Reemplaza TODOS los elementos según una función lambda.
// Ejemplo: Poner todo en mayúsculas.
playlist.replaceAll(cancion -> cancion.toUpperCase());

// sort(Comparator<? super E> c): Ordena la lista.
// null -> usa el orden natural (alfabético para Strings).
playlist.sort(null); 

// Orden inverso usando un Comparator
playlist.sort(Comparator.reverseOrder());

// remove(int index): Borra por posición. Devuelve el elemento borrado.
String borrada = playlist.remove(0); 

// remove(Object o): Borra la primera aparición del objeto. Devuelve boolean.
boolean fueBorrada = playlist.remove("WONDERWALL");

// removeAll(Collection<?> c): Borra de mi lista TODO lo que aparezca en la otra lista.
var cancionesProhibidas = List.of("DESPACITO", "MACARENA");
playlist.removeAll(cancionesProhibidas);

// removeIf(Predicate<? super E> filter): Borra si cumple una condición (Lambda).
// Ejemplo: Borrar canciones muy cortas o que empiecen por 'T'.
playlist.removeIf(cancion -> cancion.startsWith("T"));

// retainAll(Collection<?> c): "Quédate SOLO con esto". Lo contrario a removeAll.
// Borra todo lo que NO esté en la colección pasada.
var soloRock = List.of("BOHEMIAN RHAPSODY", "THUNDERSTRUCK");
playlist.retainAll(soloRock); // Si 'Imagine' estaba, se borra.

// clear(): Borra TODO. Reseteo de fábrica.
// playlist.clear();

// forEach(Consumer<? super E> action): La forma moderna y elegante (Lambda).
playlist.forEach(cancion -> System.out.println("Reproduciendo: " + cancion));

// iterator(): Devuelve un objeto Iterator estándar.
// Útil si necesitas borrar elementos MIENTRAS recorres (aunque removeIf es mejor ahora).
var it = playlist.iterator();
while(it.hasNext()) {
    String c = it.next();
    System.out.println("Iterando: " + c);
}

// listIterator(): Un iterador más potente. Permite ir hacia atrás y adelante.
var listIt = playlist.listIterator();
while(listIt.hasNext()) listIt.next(); // Vamos al final
while(listIt.hasPrevious()) { // Vamos marcha atrás
    System.out.println("Rewind: " + listIt.previous());
}

// spliterator(): "Splitable Iterator". Diseñado para procesamiento paralelo.
// Raro de usar manualmente en FP, pero es la base de los Streams paralelos.
var split = playlist.spliterator();
// tryAdvance intenta procesar un elemento, devuelve false si no quedan.
split.tryAdvance(c -> System.out.println("Spliterator vio: " + c));

// ensureCapacity(int minCapacity): Pre-reserva memoria.
// Si sabes que vas a meter 1 millón de datos, haz esto antes para evitar
// que Java tenga que redimensionar el array interno 20 veces.
ArrayList<Integer> numeros = new ArrayList<>();
numeros.ensureCapacity(1000); 

// trimToSize(): Reduce la capacidad interna al tamaño actual.
// Si reservaste 1000 huecos pero solo usas 5, esto libera memoria.
numeros.trimToSize();

// subList(int fromIndex, int toIndex): Crea una VISTA de una parte de la lista.
// ¡OJO! No es una copia. Si modificas la sublista, modificas la original.
// Rango: [from, to) -> Incluye el inicio, excluye el final.
List<String> top3 = playlist.subList(0, Math.min(3, playlist.size()));

// clone(): Crea una copia superficial (Shallow Copy) del ArrayList.
// Devuelve Object, así que hay que castear.
Object copiaObjeto = playlist.clone();
ArrayList<String> copiaLista = (ArrayList<String>) playlist.clone();

// toArray(): Convierte la lista en un array clásico [].
// Opción 1: Devuelve Object[]
Object[] arraySimple = playlist.toArray();

// Opción 2: Devuelve T[] (Tipado). Es la recomendada.
// Pasamos un array de tamaño 0 para que Java cree uno nuevo del tamaño correcto.
String[] arrayTipado = playlist.toArray(new String[0]);