1. Qué es la interfaz Collection
En Java, una interfaz es como un contrato: si una clase implementa una interfaz, está obligada a proporcionar la implementación de todos sus métodos. La interfaz en sí no almacena estado ni contiene código (casi: a partir de Java 8 son posibles los métodos default, pero ahora nos importa la idea básica).
Collection es la interfaz base para la mayoría de las colecciones en Java. Define lo que una colección sabe hacer: añadir elementos, eliminar, conocer el tamaño, comprobar la presencia de elementos, etc.
public interface Collection<E> extends Iterable<E> {
int size();
boolean isEmpty();
boolean contains(Object o);
boolean add(E e);
boolean remove(Object o);
void clear();
Iterator<E> iterator();
// ... y un montón de métodos útiles más
}
Métodos clave:
- add(E e) — añadir un elemento.
- remove(Object o) — eliminar un elemento.
- size() — obtener el número de elementos.
- isEmpty() — comprobar si la colección está vacía.
- contains(Object o) — comprobar si existe un elemento.
- clear() — limpiar la colección.
- iterator() — obtener un iterador para recorrerla.
¿Por qué Map no hereda de Collection?
Map está aparte entre las colecciones. Porque Map es un conjunto de pares «clave → valor», no solo un conjunto de elementos. Tiene un contrato distinto y otro conjunto de métodos. Por ejemplo, en Map no existe el método add, porque la inserción se hace mediante put(key, value), y no tiene sentido comprobar la existencia de un valor sin conocer la clave.
2. Jerarquía de colecciones
El «árbol» mental de las interfaces principales se ve así:
Iterable
|
Collection
/ | \
List Set Queue
|
Deque
- Iterable — la interfaz más básica: todo lo que se puede recorrer con un bucle for-each.
- Collection — amplía Iterable, añade operaciones para trabajar con una colección de elementos.
- Tres ramas principales:
- List — lista ordenada, admite duplicados.
- Set — conjunto de elementos únicos; el orden depende de la implementación.
- Queue — cola (normalmente FIFO); sub-tipo — Deque (cola doble).
Y Map vive por separado:
Map
/ \
HashMap TreeMap
Visualización de la jerarquía (esquema)
+--------------------+
| Iterable<E> |
+--------------------+
|
+--------------------+
| Collection<E> |
+--------------------+
/ | \
+--------+ +-------+ +-------+
| List | | Set | | Queue |
+--------+ +-------+ +-------+
|
+------+
|Deque |
+------+
+--------------------+
| Map<K,V> |
+--------------------+
3. List: colección ordenada con duplicados
List es una colección en la que:
- El orden de los elementos importa (primero, segundo, tercero…).
- Se permiten elementos iguales (duplicados).
- Se puede obtener un elemento por índice (list.get(2)), reemplazarlo o insertarlo en cualquier posición.
Ejemplos de implementaciones: ArrayList — acceso rápido por índice; LinkedList — bueno para inserciones/eliminaciones frecuentes en medio.
import java.util.*;
List<String> shoppingList = new ArrayList<>();
shoppingList.add("Leche");
shoppingList.add("Pan");
shoppingList.add("Queso");
shoppingList.add("Pan"); // ¡Se permiten duplicados!
System.out.println(shoppingList.get(1)); // "Pan"
Métodos típicos de List:
- add(E e), add(int index, E e)
- get(int index), set(int index, E e)
- remove(int index), remove(Object o)
- indexOf(Object o), lastIndexOf(Object o)
4. Set: conjunto de elementos únicos
Set es una colección en la que:
- Cada elemento es único (no hay duplicados).
- El orden de almacenamiento no está garantizado en HashSet, puede haber ordenación en TreeSet o el orden de inserción en LinkedHashSet.
Ejemplos de implementaciones: HashSet, TreeSet, LinkedHashSet.
import java.util.*;
Set<String> uniqueNames = new HashSet<>();
uniqueNames.add("Anya");
uniqueNames.add("Boris");
uniqueNames.add("Anya"); // No se añadirá: ¡ya existe!
System.out.println(uniqueNames.contains("Anya")); // true
System.out.println(uniqueNames.size()); // 2
Métodos típicos de Set:
- add(E e), remove(Object o)
- contains(Object o)
- size(), isEmpty()
5. Map: colección de pares clave-valor
Map es una colección en la que:
- Cada elemento es un par clave → valor.
- Las claves son únicas; los valores pueden repetirse.
- Acceso rápido por clave.
Ejemplos de implementaciones: HashMap, TreeMap, LinkedHashMap.
import java.util.*;
Map<String, String> phoneBook = new HashMap<>();
phoneBook.put("Anya", "+19991112233");
phoneBook.put("Boris", "+19994445566");
phoneBook.put("Anya", "+19990001122"); // ¡Sobrescribirá el número de Anya!
System.out.println(phoneBook.get("Anya")); // "+19990001122"
System.out.println(phoneBook.containsKey("Boris")); // true
Métodos típicos de Map:
- put(K key, V value), get(K key)
- remove(K key)
- containsKey(K key), containsValue(V value)
- keySet(), values(), entrySet()
6. Visualización de la jerarquía: todo en una sola imagen
Pequeña tabla resumen:
| Interfaz | Descripción | Ejemplos de implementaciones | Características clave |
|---|---|---|---|
|
Lista ordenada | |
Acceso por índice, duplicados |
|
Conjunto de valores únicos | |
Solo elementos únicos |
|
Pares clave-valor | |
Claves únicas, valores cualesquiera |
Jerarquía en el esquema:
Collection
/ | \
List Set Queue
|
Deque
Map (por separado)
7. Cuándo usar cada interfaz
List
- Cuando importa el orden de los elementos (p. ej., el historial de acciones del usuario).
- Cuando se necesitan duplicados (p. ej., las posiciones de un pedido).
- Cuando se requiere acceso/reemplazo rápido por índice.
Set
- Cuando se necesita unicidad (email, logins, id).
- Cuando el orden no importa, o al contrario — se necesita un conjunto ordenado automáticamente (TreeSet).
Map
- Cuando hay que asociar claves y valores (id → objeto, login → perfil).
- Cuando se necesita búsqueda rápida por clave.
- Cuando las claves deben ser únicas y los valores — no.
8. Errores típicos al trabajar con la jerarquía de colecciones
Error n.º 1: usar la interfaz incorrecta en la declaración de la variable. Si escribes ArrayList<String> list = new ArrayList<>();, te atas rígidamente a la implementación. Es preferible List<String> list = new ArrayList<>(); — así es más fácil sustituir la implementación.
Error n.º 2: intentar añadir duplicados a un Set y esperar que aparezcan. No es un bug, es una característica: Set por definición no almacena duplicados. La inserción repetida se ignora.
Error n.º 3: usar Map como una colección normal. Map no es una lista ni un conjunto. Para iterar, utiliza keySet(), values() o entrySet().
Error n.º 4: esperar orden en HashSet o HashMap. HashSet y HashMap no garantizan el orden. Si es importante — usa LinkedHashSet o LinkedHashMap.
Error n.º 5: usar List para elementos únicos. Si necesitas unicidad — utiliza Set. List no evita los duplicados.
GO TO FULL VERSION