📦 Java Collections Framework — Laboratorio de Estructuras de Datos
Estudiante: Juan David Tapiero Montoya
Documento: 1094901966
Asignatura: Estructuras de Datos
Universidad: Universidad del Quindío — Facultad de Ingeniería
📋 Descripción
Este proyecto es un laboratorio práctico sobre el Java Collections Framework, donde se analizan, diseñan e implementan soluciones a cuatro escenarios del mundo real, eligiendo la estructura de datos más apropiada para cada caso según sus requisitos de eficiencia.
Cada escenario sigue una metodología de 4 fases:
- Comprender el problema — análisis previo sin programar
- Selección de la estructura — justificación técnica
- Análisis de complejidad — evaluación Big-O antes de implementar
- Implementación + medición real — benchmarks con distintos volúmenes de datos
🗂️ Estructura del Proyecto
src/main/java/co/edu/uniquindio/
├── Escenario1/
│ ├── Paciente.java
│ ├── SistemaPacientes.java
│ └── BenchmarkSistemaPacientes.java
├── Escenario2/
│ ├── Producto.java
│ ├── PlataformaVentas.java
│ └── BenchmarkPlataformaVentas.java
├── Escenario3/
│ ├── Solicitud.java
│ ├── Usuario.java
│ ├── SistemaTaxis.java
│ └── BenchmarkSistemaTaxis.java
└── Escenario4/
├── Producto.java
├── CatalogoEcommerce.java
└── BenchmarkCatalogoEcommerce.java
🏥 Escenario 1 — Sistema de Registro de Pacientes
Problema: Gestionar pacientes en un hospital con búsqueda rápida por documento y atención por nivel de gravedad.
Estructuras utilizadas
| Operación | Estructura | Complejidad |
|---|
| Registrar paciente | LinkedHashMap | O(1) |
| Buscar por documento | HashMap | O(1) |
| Verificar duplicados | HashMap | O(1) |
| Atender por prioridad | PriorityQueue | O(log n) |
Resultados del Benchmark
| Tamaño | Registro (ms) | Búsqueda (ms) | Atención (ms) | Memoria (KB) |
|---|
| 100 | 0 | 0 | 0 | 0 |
| 1,000 | 0 | 0 | 0 | 0 |
| 10,000 | 2 | 0 | 3 | 0 |
| 100,000 | 14 | 0 | 11 | 18,179 |
Conclusión
La combinación de LinkedHashMap y PriorityQueue permite un uso eficiente de los recursos: el mapa garantiza búsquedas en O(1) y la cola de prioridad asegura que el paciente más grave siempre sea atendido primero.
🛒 Escenario 2 — Plataforma de Ventas Masivas
Problema: Catálogo de productos con búsqueda por código, inserción al inicio, ordenamiento por precio y filtrado por categoría.
Estructuras utilizadas
| Operación | Estructura | Complejidad |
|---|
| Buscar por código | HashMap | O(1) |
| Inserción al inicio | LinkedList | O(1) |
| Mostrar ordenado por precio | TreeMap<Double, List> | O(log n) |
| Filtrar por categoría | HashMap<String, List> | O(1) |
Resultados del Benchmark
| Tamaño | Inserción (ms) | Búsqueda (ms) | Categoría (ms) | Orden Precio (ms) | Memoria (KB) |
|---|
| 100 | 2 | 0 | 0 | 2 | 2,048 |
| 1,000 | 1 | 0 | 0 | 1 | 0 |
| 10,000 | 6 | 0 | 0 | 4 | 3,748 |
| 100,000 | 145 | 0 | 0 | 26 | 42,920 |
Conclusión
Cada tarea requirió una estructura distinta. La combinación de HashMap, LinkedList y TreeMap permite que cada operación se ejecute con la complejidad óptima para su tipo de acceso.
🚖 Escenario 3 — Plataforma de Solicitud de Taxis
Problema: Cola de viajes con orden FIFO, cancelación por ID y consulta de pendientes.
Estructuras utilizadas
| Operación | Estructura | Complejidad |
|---|
| Registrar viaje | LinkedList (Queue) | O(1) |
| Atender viaje más antiguo | LinkedList — poll() | O(1) |
| Cancelar solicitud específica | HashMap + LinkedList | O(1) / O(n) |
| Mostrar pendientes | LinkedList | O(n) |
Resultados del Benchmark
| Tamaño | Registro (ms) | Cancelar (ms) | Atender (ms) | Pendientes (ms) | Memoria (KB) |
|---|
| 100 | 0 | 0 | 0 | 0 | 2,048 |
| 1,000 | 0 | 1 | 0 | 0 | 0 |
| 10,000 | 0 | 18 | 0 | 0 | 2,048 |
| 100,000 | 28 | 1,288 | 1 | 0 | 34,927 |
Conclusión
El cuello de botella identificado es la cancelación en la LinkedList, que es O(n). Una optimización posible es implementar un soft delete: marcar el viaje como cancelado en el HashMap y omitirlo al momento de atender, reduciendo la cancelación efectiva a O(1).
🛍️ Escenario 4 — Catálogo de Productos E-commerce
Problema: Catálogo masivo con búsqueda directa por código e inserción manteniendo orden por precio.
Estructuras utilizadas
| Operación | Estructura | Complejidad |
|---|
| Buscar por código | HashMap | O(1) |
| Insertar producto | TreeMap | O(log n) |
| Mostrar por precio | TreeMap | O(1) iteración |
Resultados del Benchmark
| Tamaño | Inserción (ms) | Búsqueda (ms) | Orden Precio (ms) | Memoria (KB) |
|---|
| 100 | 0 | 0 | 2 | 0 |
| 1,000 | 2 | 0 | 1 | 0 |
| 10,000 | 5 | 0 | 6 | 3,581 |
| 100,000 | 129 | 0 | 24 | 44,999 |
Conclusión
Al igual que en el Escenario 2, la combinación de HashMap para acceso directo y TreeMap para orden automático por precio resulta en una solución eficiente que aprovecha las fortalezas de cada estructura.
🔍 Resumen de Estructuras por Caso de Uso
| Necesidad | Estructura recomendada |
|---|
| Acceso directo por clave | HashMap |
| Acceso con orden de inserción | LinkedHashMap |
| Orden automático por clave | TreeMap |
| Cola FIFO / inserción al final | LinkedList como Queue |
| Inserción al inicio | LinkedList — addFirst() |
| Prioridad dinámica | PriorityQueue |
| Agrupación por categoría | HashMap<K, List<V>> |
▶️ Cómo ejecutar
Cada escenario tiene su propia clase Benchmark* con método main. Ejecutar directamente desde el IDE o con Maven:
# Ejemplo para Escenario 1
mvn exec:java -Dexec.mainClass="co.edu.uniquindio.Escenario1.BenchmarkSistemaPacientes"
📚 Tecnologías
- Java (JDK 11+)
- Java Collections Framework —
HashMap, LinkedHashMap, TreeMap, LinkedList, PriorityQueue
- Maven como gestor de dependencias
java.lang.management.MemoryMXBean para medición de memoria en tiempo real