03.1 ‐ Java Collections - Cyb3rh4ck/java-core-fundamentals GitHub Wiki

¡Por supuesto! Te haré una explicación completa y avanzada de Java Collections en JDK 17+, incluyendo mejoras, mejores prácticas y ejemplos avanzados. 🚀

📌 ¿Qué son las Java Collections?

Las Java Collections son un conjunto de clases e interfaces en el paquete java.util que permiten almacenar, manipular y procesar datos de manera eficiente.

La API de Collections se basa en Generics y proporciona listas, conjuntos, mapas, colas y más.

🔥 Estructura Principal de Java Collections

📌 Interfaz principal: Collection<E>

  • List<E> → Permite duplicados y mantiene el orden.
  • Set<E> → No permite duplicados.
  • Queue<E> → FIFO (First-In-First-Out), usada en colas.

📌 Estructura extendida con Map<K, V>

Aunque Map<K, V> no implementa Collection<E>, es fundamental en la API de colecciones.

📌 Diagrama de las interfaces principales:

Collection<E>
│
├── List<E>    → Listas ordenadas con elementos duplicados
│   ├── ArrayList<E>
│   ├── LinkedList<E>
│   ├── Vector<E> (obsoleto en muchos casos)
│
├── Set<E>     → No permite duplicados
│   ├── HashSet<E> (sin orden)
│   ├── LinkedHashSet<E> (orden de inserción)
│   ├── TreeSet<E> (orden natural o comparador)
│
├── Queue<E>   → FIFO
│   ├── PriorityQueue<E> (orden por prioridad)
│   ├── LinkedList<E> (doble enlace, usada como cola)
│
└── Deque<E>   → Doble cola (FIFO o LIFO)
    ├── ArrayDeque<E> (eficiente y sin sincronización)

Map<K, V>  → Almacena pares clave-valor (no hereda de Collection)
├── HashMap<K, V>       → Sin orden específico
├── LinkedHashMap<K, V> → Mantiene orden de inserción
└── TreeMap<K, V>       → Ordenado por clave

🏆 1. List: Listas en Java

Permiten duplicados, acceso por índice y son dinámicas.

✅ Ejemplo: ArrayList vs LinkedList 

import java.util.*;

public class ListExample {
    public static void main(String[] args) {
        List<String> arrayList = new ArrayList<>(List.of("A", "B", "C"));
        List<String> linkedList = new LinkedList<>(arrayList);

        arrayList.add("D");
        linkedList.add("E");

        System.out.println("ArrayList: " + arrayList);
        System.out.println("LinkedList: " + linkedList);
    }
}

📌 Diferencias clave:
✅ ArrayList es rápido para acceso por índice (O(1)), pero lento para inserciones/eliminaciones intermedias.
✅ LinkedList es rápido en inserciones/eliminaciones intermedias (O(1)), pero lento para acceso por índice (O(n)).

🚀 2. Set: Conjuntos en Java

No permiten duplicados y pueden o no mantener orden.

✅ Ejemplo: HashSet, LinkedHashSet, TreeSet 

import java.util.*;

public class SetExample {
    public static void main(String[] args) {
        Set<Integer> hashSet = new HashSet<>(Set.of(3, 1, 2, 1)); // Sin orden
        Set<Integer> linkedHashSet = new LinkedHashSet<>(Set.of(3, 1, 2, 1)); // Orden de inserción
        Set<Integer> treeSet = new TreeSet<>(Set.of(3, 1, 2, 1)); // Ordenado

        System.out.println("HashSet: " + hashSet);
        System.out.println("LinkedHashSet: " + linkedHashSet);
        System.out.println("TreeSet: " + treeSet);
    }
}

📌 Diferencias clave:
✅ HashSet → Sin orden, rápido en inserciones y búsquedas O(1).
✅ LinkedHashSet → Mantiene orden de inserción.
✅ TreeSet → Ordenado de forma natural o por comparador (O(log n)).

🎯 3. Map: Claves y Valores en Java

Map<K, V> almacena pares clave-valor.

✅ Ejemplo: HashMap, LinkedHashMap, TreeMap 

import java.util.*;

public class MapExample {
    public static void main(String[] args) {
        Map<String, Integer> hashMap = new HashMap<>();
        hashMap.put("Uno", 1);
        hashMap.put("Dos", 2);
        hashMap.put("Tres", 3);

        Map<String, Integer> linkedHashMap = new LinkedHashMap<>(hashMap); // Mantiene orden de inserción
        Map<String, Integer> treeMap = new TreeMap<>(hashMap); // Ordena por clave

        System.out.println("HashMap: " + hashMap);
        System.out.println("LinkedHashMap: " + linkedHashMap);
        System.out.println("TreeMap: " + treeMap);
    }
}

📌 Diferencias clave:
✅ HashMap → Sin orden, rápido en búsquedas e inserciones O(1).
✅ LinkedHashMap → Mantiene orden de inserción.
✅ TreeMap → Ordena por clave automáticamente O(log n).

⚡ 4. Queue y Deque: Colas en Java

Las colas (Queue<E>) siguen el modelo FIFO (First-In, First-Out).

✅ Ejemplo: PriorityQueue (ordenada por prioridad)

import java.util.*;

public class QueueExample {
    public static void main(String[] args) {
        Queue<Integer> priorityQueue = new PriorityQueue<>(List.of(4, 1, 3, 2));
        
        while (!priorityQueue.isEmpty()) {
            System.out.print(priorityQueue.poll() + " "); // 1 2 3 4
        }
    }
}

✅ La PriorityQueue mantiene el menor elemento primero.

🔥 Novedades en Java 17+

  1. List.of(), Set.of(), Map.of() → Métodos para colecciones inmutables.
List<String> lista = List.of("A", "B", "C"); // Inmutable
Set<Integer> conjunto = Set.of(1, 2, 3); // Inmutable
Map<String, Integer> mapa = Map.of("Uno", 1, "Dos", 2); // Inmutable
  1. Collectors.toUnmodifiableList() en Streams
import java.util.stream.Collectors;
import java.util.List;
import java.util.stream.Stream;

List<Integer> listaInmutable = Stream.of(1, 2, 3)
                                     .collect(Collectors.toUnmodifiableList());
  1. Inferencia con var
var lista = new ArrayList<>(List.of("A", "B", "C"));

📌 Conclusión

✅ Las Java Collections son eficientes, flexibles y optimizadas.
✅ Cada estructura tiene ventajas y desventajas según el caso de uso.
✅ Java 17+ añade mejoras como métodos inmutables y mejor inferencia de tipos.

Si necesitas más ejemplos avanzados o un caso de uso específico, dime. 🚀

⚠️ **GitHub.com Fallback** ⚠️