Colecciones en Java y polimorfismo

Una venta puede contener muchos detalles

Hasta ahora usamos referencias entre objetos. Pero una Venta puede contener muchos DetalleVenta, y un catálogo puede contener cientos de productos. Necesitamos una estructura que guarde una cantidad variable de referencias sin crear veinte atributos.

¿Qué significa List<E>?

List es una interfaz de Java: establece un contrato para secuencias ordenadas de elementos. Permite elementos repetidos y acceso mediante una posición que comienza en cero.

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

public class Venta {
    private List<DetalleVenta> detalles;

    public Venta() {
        detalles = new ArrayList<>();
    }
}

La expresión List<DetalleVenta> utiliza un genérico. La letra E representa el tipo de elemento; al escribir DetalleVenta, Java comprueba que los elementos añadidos tengan el tipo esperado.

Trabajar con List en una venta

Antes de elegir una implementación conviene dominar el contrato común. En este ejemplo suponemos que DetalleVenta ya tiene constructor y método calcularSubtotal(), como en las lecciones previas.

private List<DetalleVenta> detalles = new ArrayList<>();

public void agregarDetalle(DetalleVenta detalle) {
    detalles.add(detalle);
}

public int cantidadDeRenglones() {
    return detalles.size();
}

public double calcularTotal() {
    double total = 0;
    for (DetalleVenta detalle : detalles) {
        total += detalle.calcularSubtotal();
    }
    return total;
}

ArrayList frente a LinkedList

Las dos clases implementan List, pero organizan internamente sus datos de modo distinto.

Para La Viñeta escogeremos normalmente ArrayList: vamos a listar productos, mostrarlos en JTable, recorrerlos y consultar elementos. LinkedList es importante conocerla, pero no es automáticamente más rápida al insertar o eliminar.

Polimorfismo: cambia el objeto, no el contrato

La variable puede declararse con el tipo de la interfaz mientras que el objeto pertenece a una clase que la implementa. Esa es una forma de polimorfismo por subtipo.

List<Producto> productos = new ArrayList<>();

// También es válido:
productos = new LinkedList<>();

productos.add(new Producto(101, "Mafalda 1", 450, 8));
System.out.println(productos.size());

Las operaciones add y size siguen funcionando porque pertenecen al contrato List. La implementación concreta determina cómo se ejecutan internamente.

public static void mostrarProductos(List<Producto> productos) {
    for (Producto producto : productos) {
        System.out.println(producto.getNombre());
    }
}

Este método acepta indistintamente un ArrayList<Producto> o un LinkedList<Producto> sin duplicar el código.

Ordenar con sort y Comparator

Para mostrar un catálogo ordenado por nombre o precio podemos utilizar sort. Hay dos formas útiles: lista.sort(comparador) y Collections.sort(lista, comparador).

import java.util.Comparator;
import java.util.List;

productos.sort(
    Comparator.comparingDouble(Producto::getPrecio)
);

productos.sort(
    Comparator.comparing(
        Producto::getNombre,
        String.CASE_INSENSITIVE_ORDER
    )
);

Si quisiéramos definir el orden «natural» de la clase usaríamos Comparable, pero por ahora es más flexible pasar distintos Comparator según lo que el usuario quiere ver.

Conjuntos, mapas y árboles: ¿qué más existe?

No todo grupo de datos necesita ser una lista. Java ofrece otras interfaces e implementaciones dentro del Java Collections Framework, cada una con un propósito.

Set<String> categorias = new HashSet<>();
categorias.add("Manga");
categorias.add("Manga"); // No agrega un duplicado

Map<Long, Producto> porCodigo = new HashMap<>();
porCodigo.put(101L, producto);
Producto encontrado = porCodigo.get(101L);

¿Y los árboles?

Un árbol es una estructura jerárquica de nodos. No es una única «clase colección» para cualquier árbol: Java ofrece, entre otras, TreeSet y TreeMap, que mantienen elementos o claves ordenados mediante estructuras arbóreas equilibradas.

También existen Queue (colas), Deque (doble extremo), ArrayDeque y PriorityQueue. Basta reconocerlas por ahora; las trabajaremos cuando exista un problema que las necesite.

Una guía de elección

Una estructura no sustituye el análisis OO: primero entendemos las reglas de la tienda y después escogemos cómo almacenar y consultar sus objetos.

¿Qué colección elegirías?

Continuidad: con estas herramientas podremos gestionar objetos en memoria, crear interfaces gráficas con Swing y, más adelante, implementar persistencia mediante DAO y JDBC.