Dans cette série d'articles, je compare différentes façons de coder la même fonctionnalité. Le dernier message comparait Collections.singletonList et ArrayList pour créer une liste à un seul élément.

Dans cet article, je comparerai Collections.singletonList avec une autre méthode d'usine bien connue, List.of.

Collections : singletonList

Signature de la méthode

public static List 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);
  }

Description

Cette méthode renvoie une liste immuable contenant uniquement l'objet spécifié. Il a été introduit dans Java 1.3. Les avantages par rapport à ArrayList ont été abordés dans le dernier article, mais pour récapituler :

1. Implémentation en ligne : Initialisez avec l'élément souhaité sur une seule ligne.
2. Immuabilité : La taille de la liste et le contenu de son élément unique ne peuvent pas être modifiés.
3. Allocation de mémoire : La classe SingletonList ne contient qu'un seul champ pour un seul élément.
4. Utilisation du processeur : Le constructeur SingletonList accepte l'élément unique comme paramètre, ne nécessitant aucun redimensionnement ni manipulation de tableau.

Liste de

Signature de la méthode

liste statique 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);
  }

Description

La méthode List.of(E e) est également une méthode Factory qui renvoie une liste non modifiable. Contrairement à Collections.singletonList(E e), qui ne prend en charge qu'un seul élément, List.of prend en charge 0 à 10 éléments, ainsi que des tableaux comportant plusieurs éléments. Il a été introduit dans Java 9, 17 ans après singletonList.

Il est intéressant de noter que, contrairement à SingletonList, qui contient le commentaire :

Renvoie une liste immuable contenant uniquement l'objet spécifié.

le Array.of indique qu'il s'agit d'une Liste non modifiable :

Renvoie une liste non modifiable contenant un élément.

Cela reflète une nouvelle compréhension de l’immuabilité des collections. Selon cette documentation :

Une collection est considérée comme non modifiable si des éléments ne peuvent pas être ajoutés, supprimés ou remplacés. Cependant, une collection non modifiable n'est immuable que si les éléments contenus dans la collection sont immuables.

Malgré ces différences de terminologie, les deux méthodes d'usine ont presque les mêmes fonctionnalités. En regardant plus profondément dans la UnmodifiableList, nous pouvons trouver :

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

Quelle surprise, ils ont opté pour le terme pas si précis Immuable, cependant !

  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 seule différence est que List12 a deux champs pour potentiellement deux éléments, ce qui entraîne également une empreinte mémoire négligeable à moins de traiter des objets volumineux.

Conclusion

Cette fois, nous avons comparé les méthodes d'usine Collections.singletonList et List.of pour créer une liste à un seul élément. Nous avons discuté de la sémantique de immuable et non modifiable et avons montré que les deux méthodes sont efficaces, concises et peu gourmandes en ressources. Si vous pouvez utiliser une version Java plus récente, c'est préférable pour sa familiarité, sa clarté et parce que nous utilisons l'interface List bien plus que les collections. S'il est limité à une ancienne version de Java, Collections.singletonList reste un choix solide.