[Code vergleichen] Collections.singletonList vs. List.of

In dieser Beitragsreihe vergleiche ich verschiedene Möglichkeiten, die gleiche Funktionalität zu programmieren. Im letzten Beitrag wurden Collections.singletonList und ArrayList zum Erstellen einer Einzelelementliste verglichen.

In diesem Beitrag vergleiche ich Collections.singletonList mit einer anderen bekannten Factory-Methode, List.of.

Sammlungen::singletonList

Methodensignatur

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

Beschreibung

Diese Methode gibt eine unveränderliche Liste zurück, die nur das angegebene Objekt enthält. Es wurde in Java 1.3 eingeführt. Die Vorteile gegenüber ArrayList wurden im letzten Beitrag behandelt, aber um es noch einmal zusammenzufassen:

1. Inline-Implementierung:Initialisierung mit dem gewünschten Element in einer einzigen Zeile.
2. Unveränderlichkeit:Die Größe der Liste und der Inhalt ihres einzelnen Elements können nicht geändert werden.
3. Speicherzuweisung: Die SingletonList-Klasse enthält nur ein Feld für das einzelne Element.
4. CPU-Auslastung: Der SingletonList-Konstruktor akzeptiert das einzelne Element als Parameter und erfordert keine Größenänderung oder Array-Manipulation.

Liste::von

Methodensignatur

statisch Liste of()

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

Beschreibung

Die List.of(E e)-Methode ist auch eine Factory-Methode, die eine nicht veränderbare Liste zurückgibt. Im Gegensatz zu Collections.singletonList(E e), das nur ein Element unterstützt, unterstützt List.of 0 bis 10 Elemente sowie Arrays mit mehreren Elementen. Es wurde in Java 9 eingeführt, 17 Jahre nach singletonList.

Es ist interessant, dass es im Gegensatz zu SingletonList den Kommentar gibt:

Gibt eine unveränderliche Liste zurück, die nur das angegebene Objekt enthält.

Das Array.of gibt an, dass es sich um eine Unveränderbare Liste handelt:

Gibt eine nicht veränderbare Liste zurück, die ein Element enthält.

Dies spiegelt ein neues Verständnis der Unveränderlichkeit von Sammlungen wider. Laut dieser Dokumentation:

Eine Sammlung gilt als nicht änderbar, wenn Elemente nicht hinzugefügt, entfernt oder ersetzt werden können. Eine unveränderliche Sammlung ist jedoch nur dann unveränderlich, wenn die in der Sammlung enthaltenen Elemente unveränderlich sind.

Trotz dieser Unterschiede in der Terminologie haben beide Factory-Methoden nahezu die gleiche Funktionalität. Wenn wir tiefer in die UnmodifiableList schauen, können wir Folgendes finden:

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

Was für eine Überraschung, sie haben sich allerdings für den nicht ganz so präzisen Begriff Unveränderlich entschieden!

  static final class List12<E> extends     
    AbstractImmutableList<E> 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<E> extends
  AbstractImmutableCollection<E> implements List<E>, 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<E> operator) { throw uoe(); }
      @Override public E       set(int index, E element) { throw uoe(); }
      @Override public void    sort(Comparator<? super E> c) { throw uoe(); }

Der einzige Unterschied besteht darin, dass List12 zwei Felder für potenziell zwei Elemente hat, was ebenfalls zu einem vernachlässigbaren Speicherbedarf führt, sofern es sich nicht um große Objekte handelt.

Abschluss

Dieses Mal haben wir die Factory-Methoden Collections.singletonList und List.of verglichen, um eine Einzelelementliste zu erstellen. Wir haben über die Semantik von immutable und unmodifiable diskutiert und gezeigt, dass beide Methoden effizient, prägnant und ressourcenschonend sind. Wenn Sie eine neuere Java-Version verwenden können, ist diese wegen ihrer Vertrautheit und Klarheit vorzuziehen und weil wir die Listenschnittstelle viel häufiger als Sammlungen verwenden. Wenn man sich auf eine ältere Java-Version beschränkt, bleibt Collections.singletonList eine gute Wahl.

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