[Code vergleichen] ArrayList vs. Collections.singletonList

Ich starte einen neuen Thread, um verschiedene Möglichkeiten zum Codieren derselben Funktionalität zu vergleichen. In diesem Beitrag vergleiche ich zwei gängige Methoden zum Erstellen einer einfachen Liste mit nur einem Element. Insbesondere werde ich den am häufigsten verwendeten List-Implementierungskonstruktor und die Collections.singletonList untersuchen, eine einfache Factory-Methode zum Erstellen einer unveränderlichen Liste, die ein einzelnes Element enthält.

Array-Liste

Jedes Mal, wenn Sie eine ArrayList initialisieren, ohne ihre Anfangskapazität anzugeben, beginnt sie mit einem leeren Array. Wenn Sie das erste Element hinzufügen, wird die Größe der ArrayList mithilfe eines relativ komplizierten Algorithmus geändert, der das Kopieren des Arrays erfordert. Werfen wir einen Blick auf die ArrayList-Struktur:

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

Das passiert Schritt für Schritt:

1. Ein anfängliches leeres Array elementData wird erstellt.
2. Wenn Sie das erste Element hinzufügen, wird die aktuelle Größe (die Null ist) mit der Länge des Arrays verglichen.
3. Da festgestellt wurde, dass seine Größe Null ist, muss das Array wachsen, um das neue Element aufzunehmen.
4. Die Grow-Methode wird aufgerufen, die die neue Kapazität berechnet.
5. Die neue Kapazität wird zunächst um die Hälfte der alten Kapazität erhöht, was uns mit 0 + 0/2 = 0 erlaubt.
6. Da newCapacity nicht ausreicht, um das Element aufzunehmen, wird es fortgesetzt.
7. Da festgestellt wurde, dass elementData dasselbe anfängliche leere Array ist, gibt es schließlich ein Maximum zwischen der erforderlichen Größe (1) und DEFAULT_CAPACTIY (10) zurück, was zu einem Array der Größe 10 führt.

Dieser Größenänderungsprozess ist ziemlich komplex, wenn Sie nur eine einfache Liste benötigen, die immer ein einzelnes Element enthält.

Lassen Sie uns dennoch über unsere Alternative sprechen!

Collection::singletonList

Methodensignatur:

public static Liste singletonList(T o)

Beschreibung

Diese Methode gibt eine unveränderliche Liste zurück, die nur das angegebene Objekt enthält. SingletonList wurde in Java 1.3 eingeführt und bietet mehrere Vorteile:

1. Inline-Implementierung:Sie können es mit dem gewünschten Element in einer einzigen Zeile initialisieren.

2. Unveränderlichkeit: Werfen wir einen Blick auf die Implementierung:
   

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

   Die AbstractList, von der SingletonList erbt, definiert alle veränderlichen Methoden wie folgt:
   

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

   Dadurch wird sichergestellt, dass es unmöglich ist, die Größe der Liste oder den Inhalt ihres einzelnen Elements zu ändern.

   Unveränderlichkeit ist eine äußerst vorteilhafte Eigenschaft. Auch wenn ich hier nicht näher darauf eingehen werde, können interessierte Entwickler in diesem Artikel mehr erfahren.

3. Speicherzuweisung: Die SingletonList-Klasse enthält nur ein einfaches Feld zur Aufnahme des einzelnen Elements, im Gegensatz zu ArrayList, das ein Array verwendet, das mit dem einfachen ArrayList-Konstruktor ein Array zurücklässt mit einer Größe von 10 nach Elementaddition.

4. CPU-Auslastung: Der SingletonList-Konstruktor akzeptiert das einzelne Element als Parameter und erfordert keine Größenänderung, Array-Kopie oder Manipulation. Dies ist weitaus effizienter als die ArrayList-Add-Methode.

Abschluss

In diesem Beitrag haben wir zwei Möglichkeiten verglichen, eine einfache Liste mit einem einzelnen Element zu erstellen: die Verwendung des ArrayListconstructor und der Collection.singletonList-Methode. Obwohl es sich bei ArrayList um eine flexible und häufig verwendete Datenstruktur handelt, ist sie mit unnötigem Overhead verbunden, insbesondere im Hinblick auf die Speicherzuweisung und die CPU-Auslastung beim Hinzufügen von Elementen. Dieser Aufwand umfasst die Größenänderung und das Kopieren von Arrays, was für eine Liste, die nur ein Element enthalten soll, überflüssig sein kann. Wenn Sie dieses Element jedoch ändern müssen, ist ArrayList eine geeignete Lösung.

Andererseits bietet Collection.singletonList eine effizientere Alternative zum Erstellen einer Einzelelementliste. Diese Methode ist nicht nur übersichtlicher und benutzerfreundlicher, sondern gewährleistet auch Unveränderlichkeit, was in vielen Szenarien ein erheblicher Vorteil sein kann. Es hat einen minimalen Speicherbedarf und benötigt im Vergleich zu ArrayList fast keine CPU-Ressourcen.

Zusammenfassend lässt sich sagen, dass Collection.singletonList aufgrund seiner Effizienz, Einfachheit und Unveränderlichkeit für eine einfache, unveränderliche Liste mit nur einem Element die bessere Wahl ist. Wenn Sie jedoch das Element in der Liste ändern müssen, könnte die ArrayList die geeignetere Wahl sein.

Im nächsten Beitrag vergleiche ich eine weitere Alternative für eine Einzelelementliste: List.of Factory-Methode. Bis später!

Das obige ist der detaillierte Inhalt von[Code vergleichen] ArrayList vs. Collections.singletonList. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!