En esta serie de publicaciones, comparo diferentes formas de codificar la misma funcionalidad. La última publicación comparó Collections.singletonList y ArrayList para crear una lista de un solo elemento.

En esta publicación compararé Collections.singletonList con otro método de fábrica conocido, List.of.

Colecciones::singletonList

Firma del método

Lista pública estática lista singleton(T o)

  public static void main(String[] args) {
    final var addresses = Collections.singletonList(
        new Address(
            "742 Evergreen Terrace",
            "Springfield",
            "New York",
            "13468",
            "US"
        ));

    System.out.println(addresses);
  }

Descripción

Este método devuelve una lista inmutable que contiene solo el objeto especificado. Fue introducido en Java 1.3. Las ventajas sobre ArrayList se trataron en la última publicación, pero para resumir:

1. Implementación en línea: Inicializar con el elemento deseado en una sola línea.
2. Inmutabilidad: El tamaño de la lista y el contenido de su único elemento no se pueden cambiar.
3. Asignación de memoria: La clase SingletonList contiene solo un campo para un solo elemento.
4. Uso de CPU: El constructor SingletonList acepta el elemento único como parámetro, sin necesidad de cambiar el tamaño ni manipular la matriz.

Lista de

Firma del método

lista estática de()

  public static void main(String[] args) {
     final var addresses2 = List.of(
        new Address(
            "1007 Mountain Drive",
            "Bristol Township",
            "New Jersey",
            null,
            "US"
        ));

    System.out.println(addresses2);
  }

Descripción

El método List.of(E e) también es un método de fábrica que devuelve una lista no modificable. A diferencia de Collections.singletonList(E e), que admite solo un elemento, List.of admite de 0 a 10 elementos, así como matrices con múltiples elementos. Se introdujo en Java 9, 17 años después de singletonList.

Es interesante notar que, a diferencia de SingletonList, que tiene el comentario:

Devuelve una lista inmutable que contiene solo el objeto especificado.

el Array.of indica que es una Lista no modificable:

Devuelve una lista no modificable que contiene un elemento.

Esto refleja una nueva comprensión de la inmutabilidad de las colecciones. Según esta documentación:

Una colección se considera no modificable si no se pueden agregar, eliminar o reemplazar elementos. Sin embargo, una colección no modificable solo es inmutable si los elementos contenidos en la colección son inmutables.

A pesar de estas diferencias en la terminología, ambos métodos de fábrica tienen casi la misma funcionalidad. Mirando más profundamente dentro de UnmodifiableList, podemos encontrar:

  static  List of(E e1) {
      return new ImmutableCollections.List12(e1);
  }

¡Qué sorpresa, aunque eligieron el término no tan preciso Inmutable!

  static final class List12 extends     
    AbstractImmutableList implements Serializable {

        @Stable
        private final E e0;

        @Stable
        private final E e1;

        List12(E e0) {
            this.e0 = Objects.requireNonNull(e0);
            this.e1 = null;
        }
        ...
    }

static abstract class AbstractImmutableList extends
  AbstractImmutableCollection implements List, RandomAccess {

      // all mutating methods throw UnsupportedOperationException
      @Override public void    add(int index, E element) { throw uoe(); }
      @Override public boolean addAll(int index, Collection extends E> c) { throw uoe(); }
      @Override public E       remove(int index) { throw uoe(); }
      @Override public void    replaceAll(UnaryOperator operator) { throw uoe(); }
      @Override public E       set(int index, E element) { throw uoe(); }
      @Override public void    sort(Comparator super E> c) { throw uoe(); }

La única diferencia es que List12 tiene dos campos para potencialmente dos elementos, lo que también resulta en una huella de memoria insignificante a menos que se trate de objetos grandes.

Conclusión

Esta vez, comparamos los métodos de fábrica Collections.singletonList y List.of para crear una lista de un solo elemento. Discutimos sobre la semántica de inmutable y inmodificable y demostramos que ambos métodos son eficientes, concisos y con pocos recursos. Si puede utilizar una versión de Java más reciente, es preferible por su familiaridad, claridad y porque utilizamos la interfaz Lista mucho más que Colecciones. Si se restringe a una versión anterior de Java, Collections.singletonList sigue siendo una opción sólida.