Visión general de las colecciones de Java — para qué sirven las colecciones

1. Introducción

En su momento ya tratamos los «arrays infinitos», es decir, las listas. Profundicemos ahora en nuestros conocimientos y, para ello, volvamos a preguntarnos qué es un «array clásico». Si te fijas, se parece a una caja de herramientas con un número fijo de compartimentos. Supongamos que la caja tiene 10 compartimentos. Te aparece una 11.ª herramienta, ¿y ahora qué? ¡Toca comprar una caja nueva! Pues un array tradicional tiene tamaño fijo y, tras crearlo, su longitud, sea la que sea, no cambiará.

Si necesitas añadir o eliminar un elemento, tienes que crear un nuevo array y copiar los datos manualmente. En un array es fácil y rápido encontrar un elemento por índice, pero insertar un elemento en medio del array no es simplemente «insertar», sino «desplazar todo a la derecha», y al eliminar — «desplazar todo a la izquierda». Es lento e incómodo. Además, el array no contiene ninguna «lógica» adicional: solo mantiene un conjunto de celdas, y la ordenación, la búsqueda por contenido o la comprobación de unicidad hay que hacerlas con medios externos.

Ejemplo: lista dinámica de estudiantes

Supongamos que estás creando una aplicación para gestionar estudiantes en un grupo. Al principio en el grupo hay 5 personas, luego llega una más y después alguien se va. Con un array se vería así:

String[] students = new String[5];
students[0] = "Iván";
students[1] = "María";
// y así sucesivamente...

// Vaya, ha llegado un estudiante más
// ¡Hay que crear un nuevo array!
String[] newStudents = new String[6];
for (int i = 0; i < students.length; i++) {
    newStudents[i] = students[i];
}
newStudents[5] = "Alexei";
students = newStudents;

¿Cómodo? Pues no, ni mucho menos. ¿Y si estas operaciones son muchas? Entonces ya apetece algo más cómodo...

2. ¿Qué es una colección?

Una colección es un objeto que sirve de contenedor para almacenar un grupo de otros objetos (elementos). Las colecciones permiten añadir, eliminar e iterar elementos, así como realizar otras operaciones: búsqueda, ordenación, filtrado, etc.

En Java, todas las colecciones implementan o heredan de la interfaz Collection (o, para los mapeos, de Map). Una colección no es simplemente «un montón de cosas», sino una estructura que ofrece un conjunto de métodos cómodo y bien diseñado para trabajar con los elementos.

¿Por qué las colecciones son objetos?

Porque las colecciones están implementadas como clases, lo que significa que puedes crear colecciones de cualquier tipo de objeto, combinarlas, heredarlas, ampliarlas y usarlas en tus clases y métodos.

Ejemplo:

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

List<String> students = new ArrayList<>();
students.add("Iván");
students.add("María");
students.add("Alexei");

¡Voilà! Ahora puedes añadir tantos estudiantes como quieras sin preocuparte por el tamaño del array.

3. Tareas típicas que resuelven las colecciones

Las colecciones son una navaja suiza para trabajar con datos. Estas son algunas de las tareas que permiten resolver:

• Almacenamiento de listas dinámicas de datos: Por ejemplo, una lista de estudiantes, tareas en un planificador, mensajes en un chat.
• Búsqueda y filtrado: Encontrar rápidamente un elemento, comprobar su existencia, obtener todos los elementos que cumplan una condición.
• Ordenación: Ordenar fácilmente los elementos por el criterio necesario.
• Eliminación y adición de elementos: Insertar y eliminar elementos en cualquier lugar de la colección sin necesidad de copiar arrays manualmente.
• Agrupación por clave: Por ejemplo, una agenda telefónica en la que a cada nombre le corresponde un número de teléfono.
• Garantía de unicidad: Por ejemplo, el conjunto de todas las palabras únicas de un texto.

Ejemplo: agenda telefónica

Con array:

• ¿Cómo encontrar el número por nombre? Tendrás que recorrer el array y comparar los nombres.
• ¿Cómo añadir una nueva pareja? Habrá que ampliar el array.
• ¿Cómo garantizar que los nombres no se repiten? Aún más complicado.

Con colección:

• Usamos Map<String, String> — y todo funciona «de serie».

4. Visión general de los tipos principales de colecciones

En Java, las colecciones se dividen en tres grupos principales:

Listas (List)

• Colecciones ordenadas, admiten duplicados.
• Se puede obtener un elemento por índice.
• Ejemplos: ArrayList, LinkedList.

Conjuntos (Set)

• Almacenan solo elementos únicos.
• No hay acceso por índice.
• Ejemplos: HashSet, TreeSet.

Mapas (Map)

• Almacenan pares clave-valor.
• Búsqueda rápida por clave.
• Ejemplos: HashMap, TreeMap.

Esquema visual (muy aproximado):

+------------------+       +-------------------+      +---------------------+
|     List         |       |        Set        |      |         Map         |
|------------------|       |-------------------|      |---------------------|
| [a, b, c, d, a]  |       | {a, b, c, d}      |      | {a=1, b=2, c=3}     |
| Indexación: sí   |       | Indexación: no    |      | Búsqueda por clave  |
| Duplicados: sí   |       | Duplicados: no    |      | Claves únicas       |
+------------------+       +-------------------+      +---------------------+

5. Matices útiles

¿Cuándo usar cada colección?

List — cuando importa el orden de los elementos, se necesitan duplicados y se requiere acceso por índice (por ejemplo, una lista de tareas, el historial de mensajes).

Set — cuando solo se necesitan elementos únicos y el orden no es importante (por ejemplo, el conjunto de usuarios únicos).

Map — cuando hay que asociar claves con valores (por ejemplo, una agenda telefónica donde el nombre es la clave y el teléfono el valor).

Analogías de la vida real

List — la cola del comedor: el primero en llegar es el primero en ser atendido; se puede hacer cola varias veces (duplicados).

Set — la lista de invitados a una fiesta: cada invitado aparece solo una vez (unicidad).

Map — la libreta de direcciones: cada nombre tiene su teléfono.

Chuleta rápida: colecciones vs arrays

6. Relación de las colecciones con la POO

Las colecciones son objetos que implementan ciertas interfaces (List, Set, Map). Esto significa que puedes:

• Almacenar en colecciones cualquier objeto, incluidos instancias de tus propias clases.
• Crear colecciones de colecciones (por ejemplo, una lista de listas).
• Usar colecciones como parámetros y valores de retorno de métodos.
• Ampliar la funcionalidad de las colecciones mediante herencia y composición.

Ejemplo: colección de objetos de tu clase

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

class Student {
    String name;
    int age;
    // Constructor, getters/setters, etc.
}

public class Main {
    public static void main(String[] args) {
        List<Student> group = new ArrayList<>();
        group.add(new Student("Iván", 20));
        group.add(new Student("María", 21));
        // y así sucesivamente...
    }
}

7. Errores típicos al trabajar con colecciones

Error n.º 1: uso de colecciones sin tipo (raw types).
Si escribes ArrayList list = new ArrayList(), al añadir cualquier objeto (por ejemplo, cadenas y números mezclados) el compilador no se quejará, pero luego al intentar extraer un elemento y convertirlo al tipo deseado puedes obtener un error en tiempo de ejecución (ClassCastException). Usa siempre genéricos: ArrayList<String> list = new ArrayList<>().

Error n.º 2: olvidaste importar la clase necesaria.
Si ves el error «cannot find symbol», comprueba que al principio del archivo esté la línea import java.util.ArrayList; o el import necesario para tu colección.

Error n.º 3: confundir colecciones y arrays.
¡Una colección no es un array! Una colección no tiene el campo length; en su lugar usa el método size(). Un array no tiene el método add(), y una colección no tiene el operador [] para el acceso por índice (solo en listas mediante get(index)).

Error n.º 4: esperar que el orden de los elementos siempre se mantenga.
Si utilizas Set o Map, el orden de los elementos no está garantizado (a menos que uses implementaciones especiales como LinkedHashSet o TreeMap). Para datos ordenados usa List o las colecciones correspondientes.

Error n.º 5: uso de tipos primitivos en colecciones.
Las colecciones solo pueden almacenar objetos, no primitivos. Es decir, no se puede crear List<int>, solo List<Integer>. ¡No olvides las clases envoltorio!