Colecciones en Java: ArrayList, HashMap, Set y más

                    Iterable
                       │
                   Collection              Map
                   /   |   \                │
                 /     |     \          ┌───┴───┐
              List    Set   Queue    HashMap  SortedMap
              / \     / \     |                  │
      ArrayList  │  HashSet  Deque            TreeMap
      LinkedList │  TreeSet  / \
                 │  LinkedHS  ArrayDeque
            SortedSet         PriorityQueue
                │
             TreeSet

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

public class EjemploArrayList {
    public static void main(String[] args) {
        // Crear un ArrayList con genéricos (type-safe)
        List<String> lenguajes = new ArrayList<>();

        // Añadir elementos
        lenguajes.add("Java");
        lenguajes.add("Python");
        lenguajes.add("JavaScript");
        lenguajes.add("C++");
        lenguajes.add("Java");  // Los duplicados están permitidos

        System.out.println("Lista completa: " + lenguajes);
        System.out.println("Elemento en índice 2: " + lenguajes.get(2));
        System.out.println("Tamaño: " + lenguajes.size());

        // Modificar un elemento
        lenguajes.set(3, "Go");
        System.out.println("Tras modificar índice 3: " + lenguajes);

        // Eliminar por índice y por objeto
        lenguajes.remove(0);           // Elimina "Java" (el primero)
        lenguajes.remove("Python");    // Elimina la primera ocurrencia
        System.out.println("Tras eliminaciones: " + lenguajes);

        // Buscar elementos
        System.out.println("¿Contiene Go? " + lenguajes.contains("Go"));
        System.out.println("Índice de JavaScript: " + lenguajes.indexOf("JavaScript"));
    }
}

Lista completa: [Java, Python, JavaScript, C++, Java]
Elemento en índice 2: JavaScript
Tamaño: 5
Tras modificar índice 3: [Java, Python, JavaScript, Go, Java]
Tras eliminaciones: [JavaScript, Go, Java]
¿Contiene Go? true
Índice de JavaScript: 0

import java.util.LinkedList;

public class EjemploLinkedList {
    public static void main(String[] args) {
        LinkedList<String> tareas = new LinkedList<>();

        // Operaciones de List
        tareas.add("Diseñar base de datos");
        tareas.add("Implementar API REST");
        tareas.add("Escribir tests unitarios");

        // Operaciones específicas de Deque
        tareas.addFirst("Definir requisitos");      // Insertar al inicio
        tareas.addLast("Desplegar en producción");   // Insertar al final

        System.out.println("Tareas: " + tareas);
        System.out.println("Primera: " + tareas.getFirst());
        System.out.println("Última: " + tareas.getLast());

        // Usar como cola (FIFO)
        String siguiente = tareas.poll();  // Retira y devuelve el primero
        System.out.println("Procesando: " + siguiente);
        System.out.println("Restantes: " + tareas);
    }
}

Tareas: [Definir requisitos, Diseñar base de datos, Implementar API REST, Escribir tests unitarios, Desplegar en producción]
Primera: Definir requisitos
Última: Desplegar en producción
Procesando: Definir requisitos
Restantes: [Diseñar base de datos, Implementar API REST, Escribir tests unitarios, Desplegar en producción]

import java.util.HashSet;
import java.util.Set;
import java.util.Arrays;

public class EjemploHashSet {
    public static void main(String[] args) {
        // Crear un HashSet e intentar añadir duplicados
        Set<String> tecnologias = new HashSet<>();
        tecnologias.add("Java");
        tecnologias.add("Spring");
        tecnologias.add("Docker");
        tecnologias.add("Java");    // Duplicado: será ignorado
        tecnologias.add("Docker");  // Duplicado: será ignorado

        System.out.println("Tecnologías únicas: " + tecnologias);
        System.out.println("Tamaño: " + tecnologias.size());  // 3

        // Operaciones de conjuntos
        Set<String> backend = new HashSet<>(Arrays.asList("Java", "Spring", "PostgreSQL"));
        Set<String> devops = new HashSet<>(Arrays.asList("Docker", "Kubernetes", "Java"));

        // Unión
        Set<String> union = new HashSet<>(backend);
        union.addAll(devops);
        System.out.println("Unión: " + union);

        // Intersección
        Set<String> interseccion = new HashSet<>(backend);
        interseccion.retainAll(devops);
        System.out.println("Intersección: " + interseccion);

        // Diferencia
        Set<String> soloBackend = new HashSet<>(backend);
        soloBackend.removeAll(devops);
        System.out.println("Solo en backend: " + soloBackend);
    }
}

Tecnologías únicas: [Java, Docker, Spring]
Tamaño: 3
Unión: [Java, Docker, Spring, PostgreSQL, Kubernetes]
Intersección: [Java]
Solo en backend: [Spring, PostgreSQL]

import java.util.TreeSet;

public class EjemploTreeSet {
    public static void main(String[] args) {
        TreeSet<Integer> calificaciones = new TreeSet<>();
        calificaciones.add(85);
        calificaciones.add(92);
        calificaciones.add(78);
        calificaciones.add(95);
        calificaciones.add(88);

        System.out.println("Ordenadas: " + calificaciones);
        System.out.println("Menor: " + calificaciones.first());
        System.out.println("Mayor: " + calificaciones.last());
        System.out.println("Menores que 90: " + calificaciones.headSet(90));
        System.out.println("Desde 85 en adelante: " + calificaciones.tailSet(85));
        System.out.println("Entre 80 y 92: " + calificaciones.subSet(80, true, 92, true));
    }
}

Ordenadas: [78, 85, 88, 92, 95]
Menor: 78
Mayor: 95
Menores que 90: [78, 85, 88]
Desde 85 en adelante: [85, 88, 92, 95]
Entre 80 y 92: [85, 88, 92]

import java.util.HashMap;
import java.util.Map;

public class Inventario {
    public static void main(String[] args) {
        // Clave: código producto, Valor: cantidad en stock
        Map<String, Integer> stock = new HashMap<>();

        // Añadir productos
        stock.put("LAPTOP-001", 45);
        stock.put("MOUSE-002", 200);
        stock.put("TECLADO-003", 150);
        stock.put("MONITOR-004", 30);

        // Consultar stock
        System.out.println("Stock del monitor: " + stock.get("MONITOR-004"));

        // getOrDefault: evitar NullPointerException
        int stockCable = stock.getOrDefault("CABLE-005", 0);
        System.out.println("Stock del cable: " + stockCable);

        // Actualizar stock (venta de 5 laptops)
        stock.put("LAPTOP-001", stock.get("LAPTOP-001") - 5);

        // Recorrer el mapa completo
        System.out.println("\n--- Inventario completo ---");
        for (Map.Entry<String, Integer> entrada : stock.entrySet()) {
            System.out.printf("%-15s → %d unidades%n",
                entrada.getKey(), entrada.getValue());
        }

        // Verificar existencia de clave
        System.out.println("\n¿Existe LAPTOP-001? " + stock.containsKey("LAPTOP-001"));
        System.out.println("¿Algún producto con 200 unidades? " + stock.containsValue(200));

        // Métodos Java 8+
        stock.putIfAbsent("CABLE-005", 500);  // Solo inserta si no existe
        stock.merge("MOUSE-002", 50, Integer::sum);  // Sumar 50 al stock actual
        System.out.println("\nStock del ratón actualizado: " + stock.get("MOUSE-002"));
    }
}

Stock del monitor: 30
Stock del cable: 0

--- Inventario completo ---
LAPTOP-001      → 40 unidades
MOUSE-002       → 200 unidades
MONITOR-004     → 30 unidades
TECLADO-003     → 150 unidades

¿Existe LAPTOP-001? true
¿Algún producto con 200 unidades? true

Stock del ratón actualizado: 250

import java.util.TreeMap;
import java.util.Map;

public class RankingPuntuaciones {
    public static void main(String[] args) {
        // Orden natural de las claves (alfabético)
        TreeMap<String, Integer> ranking = new TreeMap<>();
        ranking.put("Ana", 950);
        ranking.put("Carlos", 870);
        ranking.put("Elena", 920);
        ranking.put("Bruno", 890);

        System.out.println("Ranking alfabético: " + ranking);
        System.out.println("Primer jugador: " + ranking.firstKey());
        System.out.println("Último jugador: " + ranking.lastKey());

        // Jugadores del rango B-D (inclusive)
        Map<String, Integer> rangoBC = ranking.subMap("B", true, "D", true);
        System.out.println("Jugadores B-D: " + rangoBC);
    }
}

Ranking alfabético: {Ana=950, Bruno=890, Carlos=870, Elena=920}
Primer jugador: Ana
Último jugador: Elena
Jugadores B-D: {Bruno=890, Carlos=870}

import java.util.PriorityQueue;
import java.util.ArrayDeque;
import java.util.Deque;

public class EjemploColas {
    public static void main(String[] args) {
        // PriorityQueue: ordena automáticamente por valor natural
        PriorityQueue<Integer> urgencias = new PriorityQueue<>();
        urgencias.add(5);  // Prioridad baja
        urgencias.add(1);  // Prioridad alta
        urgencias.add(3);  // Prioridad media

        System.out.println("--- Cola de prioridad ---");
        while (!urgencias.isEmpty()) {
            System.out.println("Procesando prioridad: " + urgencias.poll());
        }

        // ArrayDeque: usarla como pila (LIFO)
        System.out.println("\n--- Pila con ArrayDeque ---");
        Deque<String> pila = new ArrayDeque<>();
        pila.push("Página 1");
        pila.push("Página 2");
        pila.push("Página 3");

        while (!pila.isEmpty()) {
            System.out.println("Volviendo a: " + pila.pop());
        }
    }
}

--- Cola de prioridad ---
Procesando prioridad: 1
Procesando prioridad: 3
Procesando prioridad: 5

--- Pila con ArrayDeque ---
Volviendo a: Página 3
Volviendo a: Página 2
Volviendo a: Página 1

import java.util.*;
import java.util.stream.Collectors;

public class FormasDeIteracion {
    public static void main(String[] args) {
        List<String> ciudades = List.of("Madrid", "Barcelona", "Sevilla", "Valencia");

        // 1. Bucle for clásico (solo para List, acceso por índice)
        System.out.println("--- for clásico ---");
        for (int i = 0; i < ciudades.size(); i++) {
            System.out.println(i + ": " + ciudades.get(i));
        }

        // 2. For-each (para cualquier Iterable)
        System.out.println("\n--- for-each ---");
        for (String ciudad : ciudades) {
            System.out.println(ciudad);
        }

        // 3. Iterator explícito (permite eliminar durante iteración)
        System.out.println("\n--- Iterator ---");
        List<String> copia = new ArrayList<>(ciudades);
        Iterator<String> it = copia.iterator();
        while (it.hasNext()) {
            String ciudad = it.next();
            if (ciudad.startsWith("S")) {
                it.remove();  // Eliminación segura durante iteración
            }
        }
        System.out.println("Sin ciudades con S: " + copia);

        // 4. Streams (Java 8+): estilo funcional declarativo
        System.out.println("\n--- Streams ---");
        List<String> conM = ciudades.stream()
            .filter(c -> c.startsWith("M") || c.startsWith("V"))
            .map(String::toUpperCase)
            .sorted()
            .collect(Collectors.toList());
        System.out.println("Filtradas y en mayúsculas: " + conM);
    }
}

--- for clásico ---
0: Madrid
1: Barcelona
2: Sevilla
3: Valencia

--- for-each ---
Madrid
Barcelona
Sevilla
Valencia

--- Iterator ---
Sin ciudades con S: [Madrid, Barcelona, Valencia]

--- Streams ---
Filtradas y en mayúsculas: [MADRID, VALENCIA]

import java.util.*;

public class EjemploCollections {
    public static void main(String[] args) {
        List<Integer> numeros = new ArrayList<>(Arrays.asList(34, 12, 56, 7, 89, 23));

        // Ordenar
        Collections.sort(numeros);
        System.out.println("Ordenada: " + numeros);

        // Orden inverso
        Collections.sort(numeros, Collections.reverseOrder());
        System.out.println("Invertida: " + numeros);

        // Mezclar aleatoriamente
        Collections.shuffle(numeros);
        System.out.println("Mezclada: " + numeros);

        // Valor máximo y mínimo
        System.out.println("Máximo: " + Collections.max(numeros));
        System.out.println("Mínimo: " + Collections.min(numeros));

        // Frecuencia de un elemento
        List<String> colores = Arrays.asList("rojo", "azul", "rojo", "verde", "rojo");
        System.out.println("Frecuencia de 'rojo': " + Collections.frequency(colores, "rojo"));

        // Crear lista inmutable (Java 9+)
        List<String> inmutable = List.of("uno", "dos", "tres");
        // inmutable.add("cuatro");  // Lanzaría UnsupportedOperationException

        // Vista no modificable de una lista existente
        List<Integer> soloLectura = Collections.unmodifiableList(numeros);
        System.out.println("Solo lectura: " + soloLectura);
    }
}

// ❌ SIN genéricos (Java 1.4 y anteriores) — código inseguro
List listaRaw = new ArrayList();
listaRaw.add("texto");
listaRaw.add(42);  // Compila, pero mezcla tipos
String s = (String) listaRaw.get(1);  // ClassCastException en tiempo de ejecución

// ✅ CON genéricos (Java 5+) — el compilador previene errores
List<String> listaSegura = new ArrayList<>();
listaSegura.add("texto");
// listaSegura.add(42);  // ¡ERROR DE COMPILACIÓN! No compila.
String s2 = listaSegura.get(0);  // No necesita casting

// ✅ Buena práctica: tipo interfaz a la izquierda
List<String> nombres = new ArrayList<>();
Set<Integer> ids = new HashSet<>();
Map<String, Double> precios = new HashMap<>();

// ❌ Mala práctica: tipo concreto a la izquierda (acopla el código)
ArrayList<String> nombres2 = new ArrayList<>();

import java.util.*;
import java.util.stream.Collectors;

class Libro {
    private String isbn;
    private String titulo;
    private String autor;
    private String genero;
    private int anio;
    private boolean disponible;

    public Libro(String isbn, String titulo, String autor, String genero, int anio) {
        this.isbn = isbn;
        this.titulo = titulo;
        this.autor = autor;
        this.genero = genero;
        this.anio = anio;
        this.disponible = true;
    }

    // Getters
    public String getIsbn() { return isbn; }
    public String getTitulo() { return titulo; }
    public String getAutor() { return autor; }
    public String getGenero() { return genero; }
    public int getAnio() { return anio; }
    public boolean isDisponible() { return disponible; }
    public void setDisponible(boolean disponible) { this.disponible = disponible; }

    @Override
    public String toString() {
        return String.format("«%s» de %s (%d) [%s]",
            titulo, autor, anio, disponible ? "Disponible" : "Prestado");
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Libro)) return false;
        return isbn.equals(((Libro) o).isbn);
    }

    @Override
    public int hashCode() { return isbn.hashCode(); }
}

public class SistemaBiblioteca {
    // Catálogo completo (List para mantener orden de registro)
    private List<Libro> catalogo = new ArrayList<>();

    // Índice rápido por ISBN (Map para búsqueda O(1))
    private Map<String, Libro> indicePorIsbn = new HashMap<>();

    // Géneros disponibles (TreeSet para orden alfabético sin duplicados)
    private Set<String> generos = new TreeSet<>();

    // Cola de reservas (LinkedList como Queue FIFO)
    private Queue<String> colaReservas = new LinkedList<>();

    public void agregarLibro(Libro libro) {
        catalogo.add(libro);
        indicePorIsbn.put(libro.getIsbn(), libro);
        generos.add(libro.getGenero());
        System.out.println("✅ Añadido: " + libro);
    }

    public Libro buscarPorIsbn(String isbn) {
        return indicePorIsbn.get(isbn);
    }

    public List<Libro> buscarPorGenero(String genero) {
        return catalogo.stream()
            .filter(l -> l.getGenero().equalsIgnoreCase(genero))
            .collect(Collectors.toList());
    }

    public void prestarLibro(String isbn) {
        Libro libro = indicePorIsbn.get(isbn);
        if (libro != null && libro.isDisponible()) {
            libro.setDisponible(false);
            System.out.println("📕 Prestado: " + libro.getTitulo());
        } else if (libro != null) {
            colaReservas.add(isbn);
            System.out.println("⏳ En cola de reservas: " + libro.getTitulo());
        } else {
            System.out.println("❌ ISBN no encontrado: " + isbn);
        }
    }

    public void mostrarEstadisticas() {
        long disponibles = catalogo.stream().filter(Libro::isDisponible).count();
        System.out.println("\n📊 --- Estadísticas de la biblioteca ---");
        System.out.println("Total de libros: " + catalogo.size());
        System.out.println("Disponibles: " + disponibles);
        System.out.println("Prestados: " + (catalogo.size() - disponibles));
        System.out.println("Géneros: " + generos);
        System.out.println("Reservas pendientes: " + colaReservas.size());
    }

    public static void main(String[] args) {
        SistemaBiblioteca biblioteca = new SistemaBiblioteca();

        // Registrar libros
        biblioteca.agregarLibro(new Libro("978-0-13-468599-1",
            "Effective Java", "Joshua Bloch", "Programación", 2018));
        biblioteca.agregarLibro(new Libro("978-0-596-00712-6",
            "Head First Design Patterns", "Eric Freeman", "Programación", 2020));
        biblioteca.agregarLibro(new Libro("978-84-376-0494-7",
            "Don Quijote de la Mancha", "Miguel de Cervantes", "Literatura", 1605));
        biblioteca.agregarLibro(new Libro("978-0-06-112008-4",
            "To Kill a Mockingbird", "Harper Lee", "Literatura", 1960));

        // Buscar y prestar
        Libro encontrado = biblioteca.buscarPorIsbn("978-0-13-468599-1");
        System.out.println("\nBúsqueda por ISBN: " + encontrado);

        biblioteca.prestarLibro("978-0-13-468599-1");
        biblioteca.prestarLibro("978-0-13-468599-1");  // Ya prestado → cola

        // Buscar por género
        System.out.println("\nLibros de Programación:");
        biblioteca.buscarPorGenero("Programación").forEach(l ->
            System.out.println("  · " + l));

        // Estadísticas
        biblioteca.mostrarEstadisticas();
    }
}

✅ Añadido: «Effective Java» de Joshua Bloch (2018) [Disponible]
✅ Añadido: «Head First Design Patterns» de Eric Freeman (2020) [Disponible]
✅ Añadido: «Don Quijote de la Mancha» de Miguel de Cervantes (1605) [Disponible]
✅ Añadido: «To Kill a Mockingbird» de Harper Lee (1960) [Disponible]

Búsqueda por ISBN: «Effective Java» de Joshua Bloch (2018) [Disponible]
📕 Prestado: Effective Java
⏳ En cola de reservas: Effective Java

Libros de Programación:
  · «Effective Java» de Joshua Bloch (2018) [Prestado]
  · «Head First Design Patterns» de Eric Freeman (2020) [Disponible]

📊 --- Estadísticas de la biblioteca ---
Total de libros: 4
Disponibles: 3
Prestados: 1
Géneros: [Literatura, Programación]
Reservas pendientes: 1

// ❌ INCORRECTO: modificar la lista dentro de un for-each
List<String> nombres = new ArrayList<>(Arrays.asList("Ana", "Bob", "Carlos"));
for (String nombre : nombres) {
    if (nombre.startsWith("B")) {
        nombres.remove(nombre);  // ¡ConcurrentModificationException!
    }
}

// ✅ CORRECTO: usar removeIf (Java 8+)
nombres.removeIf(nombre -> nombre.startsWith("B"));

// ✅ CORRECTO: usar Iterator.remove()
Iterator<String> it = nombres.iterator();
while (it.hasNext()) {
    if (it.next().startsWith("B")) {
        it.remove();
    }
}

// ❌ Clase sin hashCode/equals: HashSet no detecta duplicados
class Producto {
    String codigo;
    Producto(String codigo) { this.codigo = codigo; }
}
Set<Producto> set = new HashSet<>();
set.add(new Producto("A001"));
set.add(new Producto("A001"));
System.out.println(set.size());  // Imprime 2, ¡debería ser 1!

// ✅ Solución: implementar equals() y hashCode()
class ProductoCorregido {
    String codigo;
    ProductoCorregido(String codigo) { this.codigo = codigo; }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof ProductoCorregido)) return false;
        return codigo.equals(((ProductoCorregido) o).codigo);
    }

    @Override
    public int hashCode() { return codigo.hashCode(); }
}

// ❌ INCORRECTO: declarar con el tipo concreto acopla el código
ArrayList<String> lista = new ArrayList<>();
HashMap<String, Integer> mapa = new HashMap<>();

// ✅ CORRECTO: programar contra la interfaz permite cambiar la implementación
List<String> lista = new ArrayList<>();       // Fácil cambiar a LinkedList
Map<String, Integer> mapa = new HashMap<>();  // Fácil cambiar a TreeMap

// ❌ INCORRECTO: intentar ordenar objetos que no implementan Comparable
class Empleado {
    String nombre;
    int edad;
    Empleado(String nombre, int edad) { this.nombre = nombre; this.edad = edad; }
}
List<Empleado> empleados = new ArrayList<>();
empleados.add(new Empleado("Ana", 30));
empleados.add(new Empleado("Carlos", 25));
Collections.sort(empleados);  // ¡ClassCastException! Empleado no es Comparable

// ✅ CORRECTO: proporcionar un Comparator
Collections.sort(empleados, (e1, e2) -> e1.nombre.compareTo(e2.nombre));

// ✅ O bien: implementar Comparable en la clase
class EmpleadoComparable implements Comparable<EmpleadoComparable> {
    String nombre;
    int edad;
    EmpleadoComparable(String nombre, int edad) { this.nombre = nombre; this.edad = edad; }

    @Override
    public int compareTo(EmpleadoComparable otro) {
        return this.nombre.compareTo(otro.nombre);
    }
}