Java Tip 33: Collection API

La API de colecciones de Java (Collection API) es una arquitectura unificada que se encuentra en el paquete java.util y que proporciona interfaces, clases y algoritmos predefinidos para almacenar y manipular grupos de objetos de manera eficiente.

A diferencia de los arreglos estándar, las colecciones ofrecen redimensionamiento dinámico y estructuras de datos integradas como listas, conjuntos y mapas.

Lo nuevo en Java 21 en cuanto al manejo de colecciones es la introducción de las Sequenced Collections (Colecciones Secuenciadas).

Esta nueva característica resuelve un problema histórico en Java: la falta de una forma uniforme y consistente de representar colecciones con un orden de encuentro definido (es decir, que tienen un primer elemento, un último elemento, y un orden claro de principio a fin).

El problema que resuelve

Antes de Java 21, si querías obtener el primer o el último elemento de una colección, el código variaba drásticamente según el tipo de datos que estuvieras usando:

• Para una List:

  list.get(0) o list.get(list.size() - 1)
  

• Para un Deque:

  deque.getFirst() o deque.getLast()
  

• Para un SortedSet:

  set.first() o set.last()
  

No había una interfaz común que unificara estas operaciones, lo cual hacía que escribir código genérico fuera un dolor de cabeza.

Las Nuevas Interfaces

Java 21 introduce tres interfaces principales en el paquete java.util :

1. SequencedCollection<E> : Hereda de Collection<E> y añade métodos para interactuar con los extremos de la colección, además de permitir la inversión de la misma.

Métodos clave:

void addFirst(E e)

void addLast(E e)

E getFirst()

E getLast()

E removeFirst()

E removeLast()

SequencedCollection<E> reversed() // (Devuelve una vista en orden inverso sin copiar los datos).

2. SequencedSet<E> : Hereda de SequencedCollection<E> y Set<E>. Asegura que no haya elementos duplicados, pero mantiene el orden secuencial (como LinkedHashSet o SortedSet). Su método reversed() devuelve un SequencedSet<E>.

3. SequencedMap<K, V> Hereda de Map<K, V> para aquellos mapas que mantienen un orden en sus entradas (como LinkedHashMap).

Métodos clave:

Map.Entry<K,V> firstEntry() / lastEntry()

K firstKey() / lastKey()

Map.Entry<K,V> pollFirstEntry() / pollLastEntry()

SequencedMap<K,V> reversed()

SequencedSet<K> sequencedKeySet()

SequencedCollection<V> sequencedValues()

¿Cómo queda la jerarquía?

• List ahora hereda directamente de SequencedCollection. 
• LinkedHashSet implementa SequencedSet. 
• LinkedHashMap implementa SequencedMap.

ArrayList, LinkedList, TreeSet y TreeMap ahora disfrutan de estas ventajas de manera nativa gracias a esta reestructuración.

Ejemplo:

Main.java

package com.comunidad;

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

public class Main {
    public static void main(String[] args) {
        List<String> meses = new ArrayList<>(List.of("Febrero", "Marzo", "Abril"));

        // Añadir elementos en los extremos fácilmente
        meses.addFirst("Enero");
        meses.addLast("Mayo");

        System.out.println(meses); // [Enero, Febrero, Marzo, Abril, Mayo]

        // Obtener elementos de forma directa
        System.out.println("Primero: " + meses.getFirst()); // Enero
        System.out.println("Último: " + meses.getLast());   // Mayo

        // Invertir la colección en tiempo constante O(1)
        var mesesInvertidos = meses.reversed();
        System.out.println(mesesInvertidos); // [Mayo, Abril, Marzo, Febrero, Enero]
    }
}

Beneficios principales

• Consistencia: Mismos métodos para las mismas acciones, sin importar si usas listas, conjuntos o mapas ordenados. 
• Eficiencia: El método reversed() no duplica la colección en memoria; crea una vista, lo que significa que es increíblemente rápido y eficiente. 
• Menos Boilerplate: Se acabó el calcular el índice size() - 1 o usar iteradores raros solo para ver el último elemento.

Enlaces:

https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/util/Collections.html