Nesta série de postagens, estou comparando diferentes maneiras de codificar a mesma funcionalidade. A última postagem comparou Collections.singletonList e ArrayList para criar uma lista de elemento único.

Neste post vou comparar Collections.singletonList com outro método de fábrica bem conhecido, List.of.

Coleções::singletonList

Assinatura do método

public static Lista singletonList(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);
  }

Descrição

Este método retorna uma lista imutável contendo apenas o objeto especificado. Foi introduzido no Java 1.3. As vantagens sobre ArrayList foram abordadas no último post, mas para recapitular:

1. Implementação inline: Inicialize com o elemento desejado em uma única linha.
2. Imutabilidade: O tamanho da lista e o conteúdo de seu único elemento não podem ser alterados.
3. Alocação de memória: A classe SingletonList contém apenas um campo para o único elemento.
4. Uso de CPU: O construtor SingletonList aceita o elemento único como parâmetro, não exigindo redimensionamento ou manipulação de array.

Lista de

Assinatura do método

estático Lista 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);
  }

Descrição

O método List.of(E e) também é um método de fábrica que retorna uma lista não modificável. Ao contrário de Collections.singletonList(E e), que suporta apenas um elemento, List.of suporta de 0 a 10 elementos, bem como arrays com vários elementos. Foi introduzido em Java 9, 17 anos após singletonList.

É interessante notar que, ao contrário do SingletonList, que tem o comentário:

Retorna uma lista imutável contendo apenas o objeto especificado.

o Array.of afirma que é uma Lista Não Modificável:

Retorna uma lista não modificável contendo um elemento.

Isso reflete uma nova compreensão da imutabilidade das coleções. De acordo com esta documentação:

Uma coleção é considerada não modificável se os elementos não puderem ser adicionados, removidos ou substituídos. No entanto, uma coleção não modificável só é imutável se os elementos contidos na coleção forem imutáveis.

Apesar das diferenças na terminologia, ambos os métodos de fábrica têm quase a mesma funcionalidade. Olhando mais profundamente dentro da UnmodifiableList, podemos encontrar:

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

Que surpresa, eles escolheram o termo não tão preciso Imutável, no entanto!

  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(); }

A única diferença é que List12 tem dois campos para potencialmente dois elementos, o que também resulta em um consumo de memória insignificante, a menos que se trate de objetos grandes.

Conclusão

Desta vez, comparamos os métodos de fábrica Collections.singletonList e List.of para criar uma lista de elemento único. Discutimos sobre a semântica de imutável e não modificável e mostramos que ambos os métodos são eficientes, concisos e com poucos recursos. Se você puder usar uma versão Java mais recente, é preferível pela familiaridade, clareza e porque usamos muito mais a interface List do que Collections. Se restrito a uma versão Java mais antiga, Collections.singletonList continua sendo uma escolha sólida.