[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 037c7390b714f235905008570bae92dc Liste8742468051c85b06f0a0af9e3e506b5c liste singleton(T o)

<h3>
  
  
  Description
</h3>

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

<ol>
<li>
<strong>Implémentation en ligne :</strong> Vous pouvez l'initialiser avec l'élément souhaité sur une seule ligne.</li>
<li>
<p><strong>Immuabilité :</strong> Jetons un coup d'œil à sa mise en œuvre :<br>
</p>
<pre class="highlight java">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.

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.

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!