El Collections Framework es el conjunto de interfaces, implementaciones y algoritmos para trabajar con grupos de objetos.
Los arrays tienen tamaño fijo. Si creas uno de cinco posiciones y necesitas una sexta, debes crear otro y copiar los elementos.
En el mundo real, los datos son dinámicos. Los carritos de la compra crecen, los usuarios se registran y se dan de baja. Necesitamos estructuras que crezcan y decrezcan solas.
Para eso, Java nos ofrece el Java Collections Framework (JCF). Un conjunto de Interfaces y Clases diseñadas y optimizadas para manipular grupos de objetos.
Hoy vamos a ver el mapa general para que nunca más dudes sobre qué estructura usar.
La jerarquía de colecciones
El framework se divide en dos grupos principales. Es importante entender que los mapas no implementan Collection.
La interfaz Collection (la raíz)
Es la interfaz madre de los grupos de elementos individuales. Define las operaciones básicas que todos comparten:
add(E e): Añadir.remove(Object o): Borrar.size(): Cuántos hay.contains(Object o): ¿Está esto dentro?iterator(): Para recorrerlos.
De aquí salen dos ramas principales: List y Set.
La interfaz Map
Los mapas NO heredan de Collection.
¿Por qué? Porque Collection guarda cosas de una en una (objetos), y Map guarda parejas (Clave -> Valor). Tienen métodos distintos (put, get…).
Las 3 grandes estructuras
Cuando tengas que guardar datos, hazte estas preguntas para elegir la interfaz correcta:
“El orden importa y admito repetidos”
Es como una lista de la compra o una lista de tareas.
- Ordenada: El primer elemento es el 0, el segundo el 1… Mantienen el orden de inserción.
- Duplicados: Puedes tener “Leche” dos veces en la lista.
- Acceso: Puedes pedir el elemento en la posición X (
get(3)).
Implementaciones famosas: ArrayList, LinkedList.
“Lo importante es la unicidad”
Es como una bolsa de canicas o una lista de invitados VIP.
- Sin duplicados: Si intentas añadir algo que ya está, Java lo ignora.
- Sin orden (generalmente): No existe el concepto de “posición 3”. O está en la bolsa o no está.
Implementaciones famosas: HashSet, TreeSet.
“Diccionario Clave-Valor”
Es como una agenda telefónica o un diccionario real.
- Claves Únicas: No puede haber dos personas con el mismo DNI (Clave).
- Valores Repetidos: Varias personas pueden llamarse “Pepe” (Valor).
- Acceso rápido: Dame el DNI y te doy la Persona instantáneamente.
Implementaciones famosas: HashMap, TreeMap.
Wrappers: el peaje de las colecciones
Hay una regla técnica en Java que debes recordar: Las Colecciones SOLO guardan Objetos.
No puedes crear un ArrayList<int>. Los tipos primitivos (int, double, boolean) no son objetos, así que no entran en la colección.
Para solucionar esto, Java tiene las Clases Wrapper (Envoltorios):
| Primitivo | Wrapper (Objeto) |
|---|---|
int | Integer |
double | Double |
char | Character |
boolean | Boolean |
Gracias al Autoboxing (Java 5+), la conversión es automática, pero debes declarar la colección correctamente:
// MAL ❌
// List<int> numeros = new ArrayList<>();
// BIEN ✅
List<Integer> numeros = new ArrayList<>();
numeros.add(10); // Java convierte internamente el int 10 a new Integer(10)
int n = numeros.get(0); // Java lo "desempaqueta" a int automáticamente
Iteradores: recorriendo colecciones
Aunque solemos usar el bucle for-each (que funciona porque todas las colecciones implementan Iterable), a veces necesitamos el Iterator.
El Iterator es un objeto que nos permite recorrer la colección y, esto es importante, borrar elementos de forma segura mientras recorremos.
List<String> nombres = new ArrayList<>();
nombres.add("Ana");
nombres.add("Pedro");
// FOR-EACH (Solo lectura cómoda)
for (String nombre : nombres) {
System.out.println(nombre);
// nombres.remove(nombre); // ¡ERROR! ConcurrentModificationException
}
// ITERATOR (Para borrar mientras recorres)
Iterator<String> it = nombres.iterator();
while(it.hasNext()) {
String nombre = it.next();
if (nombre.equals("Ana")) {
it.remove(); // ✅ Forma segura de borrar
}
}
