📦 Colecciones en Java – Introducción
En temas anteriores hemos trabajado con arrays y con programación orientada a objetos.
Ahora vamos a estudiar una de las partes más importantes de Java: las colecciones.
Las colecciones nos permiten almacenar y gestionar grupos de objetos de forma flexible y eficiente.
1️⃣ Limitaciones de los arrays
Los arrays han sido nuestra primera estructura para almacenar varios elementos.
Ejemplo:
String[] alumnos = new String[5];
alumnos[0] = "Ana";
alumnos[1] = "Luis";
alumnos[2] = "Carlos";
Los arrays funcionan bien en muchos casos, pero tienen varias limitaciones importantes.
❌ Tamaño fijo
Cuando creamos un array debemos indicar su tamaño.
int[] numeros = new int[5];
Este array siempre tendrá tamaño 5.
Si necesitamos guardar más elementos:
- no podemos ampliarlo
- habría que crear otro array más grande
- copiar todos los datos
Esto hace que trabajar con arrays sea poco flexible cuando el número de elementos cambia.
❌ Insertar o eliminar elementos es incómodo
Si queremos insertar un elemento en medio de un array debemos desplazar todos los elementos posteriores.
Array original:
[Ana, Luis, Carlos]
Insertar "Marta" en posición 1:
[Ana, Marta, Luis, Carlos]
Para hacerlo con arrays hay que mover manualmente los valores.
❌ No tienen métodos útiles
Los arrays tienen muy pocas operaciones incorporadas.
Por ejemplo:
- no tienen método para buscar un elemento
- no tienen método para ordenar
- no tienen método para eliminar elementos
- no tienen método para comprobar si un elemento existe
Todo esto debemos programarlo a mano.
❌ Gestión manual de operaciones comunes
Operaciones muy habituales requieren código extra:
- buscar un elemento
- contar elementos
- ordenar
- eliminar duplicados
- filtrar elementos
Esto provoca que el código sea:
- más largo
- más complejo
- más propenso a errores
💡 Ejemplo real
Imagina que queremos guardar una lista de videojuegos.
Con arrays:
String[] juegos = new String[100];
Problemas:
- ¿y si solo usamos 10?
- ¿y si necesitamos 120?
- ¿cómo eliminamos uno?
- ¿cómo sabemos cuántos hay realmente?
Los arrays no están pensados para estructuras dinámicas.
🤔 Si los arrays tienen tantas limitaciones… ¿por qué los hemos aprendido?
Aunque los arrays tienen limitaciones, siguen siendo una estructura fundamental en programación. De hecho, muchas estructuras más avanzadas (como las colecciones) se construyen internamente a partir de arrays.
Por eso es importante entenderlos porque:
- Porque son la base de muchas estructuras de datos.
- Son muy eficientes, los arrays son muy rápidos.
- Son universales, existen en casi todos los lenguajes de programación: c++, c, python, javascript, etc.
2️⃣ Qué son las colecciones
Las colecciones son estructuras que permiten almacenar y gestionar grupos de objetos de forma dinámica y flexible.
A diferencia de los arrays, las colecciones:
- pueden crecer o reducirse automáticamente
- tienen muchos métodos útiles
- permiten buscar, ordenar, eliminar o recorrer elementos fácilmente
Ejemplo:
import java.util.ArrayList;
ArrayList<String> alumnos = new ArrayList<>();
alumnos.add("Ana");
alumnos.add("Luis");
alumnos.add("Carlos");
La colección gestiona automáticamente el tamaño y las operaciones.
Ventajas:
- ✔ el tamaño crece automáticamente
- ✔ podemos añadir y eliminar elementos fácilmente
- ✔ existen métodos para buscar, ordenar o recorrer
🎯 Idea clave
Una colección es un objeto que almacena otros objetos.
Por ejemplo:
- una lista de alumnos
- un conjunto de nombres únicos
- un mapa de DNI → persona
- una cola de pacientes
🧠 Concepto importante: genéricos
Las colecciones utilizan genéricos. Que veremos más adelante qué son exactamente. De momento lo que nos ayuda es a crear colecciones con distinto tipo de datos.
Ejemplo:
ArrayList<String>
ArrayList<Integer>
ArrayList<Producto>
Esto indica qué tipo de objetos puede guardar la colección.
Ejemplo:
ArrayList<Integer> numeros = new ArrayList<>();
Solo podremos guardar enteros.
⚠️ Tipos primitivos y colecciones
Las colecciones NO pueden usar tipos primitivos directamente.
❌ Incorrecto:
ArrayList<int> numeros = new ArrayList<>();
✔ Correcto:
ArrayList<Integer> numeros = new ArrayList<>();
Java utiliza clases envoltorio (Wrapper Classes).
| Tipo primitivo | Clase |
|---|---|
| int | Integer |
| double | Double |
| boolean | Boolean |
| char | Character |
3️⃣ Jerarquía general de colecciones
Las colecciones forman parte del Java Collections Framework, que es un conjunto de interfaces y clases diseñadas para trabajar con estructuras de datos.
La jerarquía principal es la siguiente:
Collection
├── List
├── Set
└── Queue
Además existe otra estructura muy importante, el Mapa:
Map
Que no hereda de Collection, pero forma parte del mismo framework.
📚 Tipos principales de colecciones
📋 List
Representa listas ordenadas de elementos.
Características:
- mantiene el orden de inserción
- permite elementos duplicados
- permite acceder por posición
Ejemplos de implementación:
ArrayList
LinkedList
Ejemplo:
import java.util.ArrayList;
import java.util.List;
List<String> nombres = new ArrayList<>();
nombres.add("Ana");
nombres.add("Luis");
nombres.add("Ana");
Resultado:
[Ana, Luis, Ana]
🧩 Set
Representa conjuntos de elementos únicos.
Características:
- no permite duplicados
- no tiene posiciones
- se usa para evitar repetidos
Implementaciones:
HashSet
TreeSet
LinkedHashSet
Ejemplo:
import java.util.HashSet;
import java.util.Set;
Set<String> nombres = new HashSet<>();
nombres.add("Ana");
nombres.add("Luis");
nombres.add("Ana");
Resultado:
[Ana, Luis]
El segundo "Ana" no se guarda.
🔑 Map
Un Map guarda pares clave → valor.
Ejemplo:
DNI → Persona
usuario → contraseña
producto → precio
Implementaciones:
HashMap
TreeMap
LinkedHashMap
Ejemplo:
import java.util.HashMap;
import java.util.Map;
Map<String, Integer> notas = new HashMap<>();
notas.put("Ana", 9);
notas.put("Luis", 7);
Resultado:
Ana → 9
Luis → 7
📊 Comparación rápida
| Estructura | Permite duplicados | Mantiene orden | Acceso por índice |
|---|---|---|---|
| List | ✔ | ✔ | ✔ |
| Set | ❌ | depende | ❌ |
| Map | clave única | depende | ❌ |
🧠 Resumen
Los arrays:
- tienen tamaño fijo
- requieren mucho código para operaciones comunes
- no son flexibles
Las colecciones:
- ✔ tamaño dinámico
- ✔ muchas operaciones útiles
- ✔ mejor organización del código
- ✔ estructuras especializadas según el problema
Principales tipos de colecciones:
- List → listas ordenadas
- Set → conjuntos sin duplicados
- Map → pares clave-valor
En las siguientes secciones estudiaremos cada una de estas estructuras en detalle.