[Comparaison de codes] ArrayList vs Collections.singletonList

Je démarre un nouveau fil de discussion pour comparer différentes façons de coder la même fonctionnalité. Dans cet article, je comparerai deux méthodes courantes pour créer une liste simple avec un seul élément. Plus précisément, j'examinerai le constructeur d'implémentation de List le plus couramment utilisé et Collections.singletonList, une méthode d'usine simple pour créer une liste immuable contenant un seul élément.

Liste des tableaux

Chaque fois que vous initialisez une ArrayList sans préciser sa capacité initiale, elle démarre avec un tableau vide. Lorsque vous ajoutez le premier élément, ArrayList se redimensionne à l'aide d'un algorithme relativement complexe qui implique la copie du tableau. Jetons un coup d'œil à la structure ArrayList :

  private static final int DEFAULT_CAPACITY = 10;
  private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

  public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
  }

  public boolean add(E e) {
    modCount++;
    add(e, elementData, size);
    return true;
  }

  private void add(E e, Object[] elementData, int s) {
    if (s == elementData.length)
        elementData = grow();
    elementData[s] = e;
    size = s + 1;
  }

  private Object[] grow() {
      return grow(size + 1);
  }

  private Object[] grow(int minCapacity) {
    return elementData = Arrays.copyOf(elementData,
                                      newCapacity(minCapacity));
  }

  private int newCapacity(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity <= 0) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return minCapacity;
    }
    return (newCapacity - MAX_ARRAY_SIZE <= 0)
        ? newCapacity
        : hugeCapacity(minCapacity);
  }

Voici ce qui se passe étape par étape :

1. Un premier tableau vide elementData est créé.
2. Lorsque vous ajoutez le premier élément, la taille actuelle (qui est zéro) est comparée à la longueur du tableau.
3. Depuis qu'il a découvert que sa taille est nulle, le tableau doit s'agrandir pour accueillir le nouvel élément.
4. La méthode de croissance est appelée, qui calcule la nouvelle capacité.
5. La nouvelle Capacité est initialement augmentée de moitié par rapport à l'ancienne capacité, ce qui nous donne 0 + 0/2 = 0.
6. Comme newCapacity n'est pas suffisant pour accueillir l'élément, cela continue.
7. Comme il a découvert que elementData est le même tableau vide initial, il renvoie finalement le maximum entre la taille requise (1) et DEFAULT_CAPACTIY (10), ce qui donne un tableau de taille 10.

Ce processus de redimensionnement est assez complexe lorsque vous n'avez besoin que d'une simple liste qui contiendra toujours un seul élément.

Cela dit, parlons de notre alternative !

Collection : singletonList

Signature de la méthode :

public statique Liste liste singleton(T o)

Description

Cette méthode renvoie une liste immuable contenant uniquement l'objet spécifié. Introduit dans Java 1.3, singletonList présente plusieurs avantages :

1. Implémentation en ligne : Vous pouvez l'initialiser avec l'élément souhaité sur une seule ligne.

2. Immuabilité : Jetons un coup d'œil à sa mise en œuvre :
   

   private static class SingletonList<E> extends AbstractList<E>
       implements RandomAccess, Serializable {
   
     private final E element;
   
     SingletonList(E obj) {
       element = obj;
     }
     ...
   }
   

   La AbstractList, dont hérite SingletonList, définit toutes les méthodes mutables comme ceci :
   

     public boolean add(E e) {
       add(size(), e);
       return true;
     }
   
     public void add(int index, E element) {
       throw new UnsupportedOperationException();
     }
   
     public E remove(int index) {
       throw new UnsupportedOperationException();
     }
   
     public E set(int index, E element) {
         throw new UnsupportedOperationException();
     }
   

   Cela garantit qu'il est impossible de chanter la taille de la liste ou le contenu de son seul élément.

   L'immuabilité est une fonctionnalité très avantageuse. Même si je n'entrerai pas dans les détails ici, les développeurs intéressés peuvent en apprendre davantage grâce à cet article.

3. Allocation de mémoire : La classe SingletonList ne contient qu'un seul champ simple pour accueillir l'élément unique, contrairement à ArrayList, qui utilise un tableau qui, en utilisant le constructeur simple ArrayList, nous laissera un tableau avec une taille de 10 après l'ajout de l'élément.

4. Utilisation du processeur : Le constructeur SingletonList accepte l'élément unique comme paramètre, ne nécessitant aucun redimensionnement, copie de tableau ou manipulation. C'est beaucoup plus efficace que la méthode d'ajout d'ArrayList.

Conclusion

Dans cet article, nous avons comparé deux façons de créer une liste simple avec un seul élément : en utilisant le constructeur ArrayList et la méthode Collection.singletonList. Bien qu'ArrayList soit une structure de données flexible et couramment utilisée, elle entraîne une surcharge inutile, notamment en termes d'allocation de mémoire et d'utilisation du processeur lors de l'ajout d'éléments. Cette surcharge inclut le redimensionnement et la copie de tableaux, qui peuvent être redondants pour une liste censée contenir un seul élément. Cependant, si vous devez modifier cet élément, ArrayList est une solution adaptée.

D'un autre côté, Collection.singletonList offre une alternative plus efficace pour créer une liste à un seul élément. Cette méthode est non seulement plus concise et plus facile à utiliser, mais garantit également l’immuabilité, ce qui peut constituer un avantage significatif dans de nombreux scénarios. Il a une empreinte mémoire minimale et ne nécessite presque aucune ressource CPU par rapport à ArrayList.

En résumé, pour une liste simple et immuable contenant un seul élément, Collection.singletonList est un choix supérieur en raison de son efficacité, de sa simplicité et de son immuabilité. Cependant, si vous devez modifier l'élément dans la liste, ArrayList pourrait être un choix plus approprié.

Dans le prochain article, je comparerai une autre alternative pour une liste à un seul élément : la méthode List.of factory. À plus tard !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!