Java 9 wprowadziła nowe metody fabryczne dla list List.of:

List<String> strings = List.of("first", "second");

Jaka jest różnica między poprzednią a nową opcją? To znaczy, jaka jest różnica między tym:

Arrays.asList(1, 2, 3);

i to:

List.of(1, 2, 3);

Arrays.asListzwraca zmienną listę, podczas gdy lista zwrócona przez List.ofjest niezmienna :

List<Integer> list = Arrays.asList(1, 2, null);
list.set(1, 10); // OK

List<Integer> list = List.of(1, 2, 3);
list.set(1, 10); // Fails with UnsupportedOperationException

Arrays.asListdopuszcza elementy puste, podczas gdy List.ofnie:

List<Integer> list = Arrays.asList(1, 2, null); // OK
List<Integer> list = List.of(1, 2, null); // Fails with NullPointerException

contains zachowuje się inaczej w przypadku wartości null:

List<Integer> list = Arrays.asList(1, 2, 3);
list.contains(null); // Returns false

List<Integer> list = List.of(1, 2, 3);
list.contains(null); // Fails with NullPointerException

Arrays.asListzwraca widok przekazanej tablicy, więc zmiany w tablicy zostaną również odzwierciedlone na liście. Do List.oftego nie jest prawdą:

Integer[] array = {1,2,3};
List<Integer> list = Arrays.asList(array);
array[1] = 10;
System.out.println(list); // Prints [1, 10, 3]

Integer[] array = {1,2,3};
List<Integer> list = List.of(array);
array[1] = 10;
System.out.println(list); // Prints [1, 2, 3]

Różnice między Arrays.asListiList.of

Zobacz JavaDocs i ten wykład autorstwa Stuarta Marksa (lub jego poprzednich wersji).

Będę używał następujących przykładów kodu:

List<Integer> listOf = List.of(...);
List<Integer> asList = Arrays.asList(...);
List<Integer> unmodif = Collections.unmodifiableList(asList);

Niezmienność strukturalna (lub: niemodyfikowalność)

Każda próba zmiany strukturalnejList.of spowoduje, że plik UnsupportedOperationException. Obejmuje to operacje takie jak dodawanie , ustawianie i usuwanie . Możesz jednak zmienić zawartość obiektów na liście (jeśli obiekty nie są niezmienne), więc lista nie jest „całkowicie niezmienna”.

To samo dotyczy niemodyfikowalnych list utworzonych za pomocą Collections.unmodifiableList. Tylko ta lista jest widokiem oryginalnej listy, więc może się zmienić, jeśli zmienisz oryginalną listę.

Arrays.asListnie jest całkowicie niezmienna, nie ma ograniczeń set.

listOf.set(1, "a");  // UnsupportedOperationException
unmodif.set(1, "a"); // UnsupportedOperationException
asList.set(1, "a");  // modified unmodif! unmodif is not truly unmodifiable

Podobnie zmiana tablicy bazowej (jeśli ją przytrzymasz) spowoduje zmianę listy.

Niezmienność strukturalna wiąże się z wieloma skutkami ubocznymi związanymi z kodowaniem obronnym, współbieżnością i bezpieczeństwem, które wykraczają poza zakres tej odpowiedzi.

Zerowa wrogość

List.ofi wszystkie kolekcje od wersji Java 1.5 nie pozwalają nulljako element. Próba przekazania nulljako elementu lub nawet wyszukiwania spowoduje utworzenie pliku NullPointerException.

Ponieważ Arrays.asListjest to kolekcja z wersji 1.2 (struktura kolekcji), umożliwia nulls.

listOf.contains(null);  // NullPointerException
unmodif.contains(null); // allowed
asList.contains(null);  // allowed

Formularz serializowany

Ponieważ List.ofzostała wprowadzona w Javie 9, a listy utworzone za pomocą tej metody mają własną (binarną) zserializowaną postać, nie można ich deserializować we wcześniejszych wersjach JDK (brak zgodności binarnej ). Możesz jednak na przykład de / serializować za pomocą JSON.

Tożsamość

Arrays.asListwywołania wewnętrzne new ArrayList, co gwarantuje nierówność odniesień.

List.ofzależy od implementacji wewnętrznej. Zwrócone instancje mogą mieć równość odwołań, ale ponieważ nie jest to gwarantowane, nie można na nich polegać.

asList1 == asList2; // false
listOf1 == listOf2; // true or false

Warto wspomnieć, że listy są równe (via List.equals), jeśli zawierają te same elementy w tej samej kolejności, niezależnie od tego, jak zostały utworzone lub jakie operacje obsługują.

asList.equals(listOf); // true i.f.f. same elements in same order

Implementacja (ostrzeżenie: szczegóły mogą ulec zmianie w przypadku wersji)

Jeśli liczba elementów na liście List.ofwynosi 2 lub mniej, elementy są przechowywane w polach wyspecjalizowanej (wewnętrznej) klasy. Przykładem jest lista przechowująca 2 elementy (częściowe źródło):

static final class List2<E> extends AbstractImmutableList<E> {
    private final E e0;
    private final E e1;

    List2(E e0, E e1) {
        this.e0 = Objects.requireNonNull(e0);
        this.e1 = Objects.requireNonNull(e1);
    }
}

W przeciwnym razie są przechowywane w tablicy w podobny sposób jak Arrays.asList.

Efektywność czasu i przestrzeni

W List.ofimplementacji, które są oparte na polu (wielkość <2) nieznacznie szybciej wykonywać niektóre operacje. Na przykład size()może zwrócić stałą bez pobierania długości tablicy i contains(E e)nie wymaga narzutu iteracji.

Tworzenie niemodyfikowalnej listy przez List.ofjest również szybsze. Porównaj powyższy konstruktor z 2 przypisaniami referencyjnymi (a nawet jednym dla dowolnej liczby elementów) do

Collections.unmodifiableList(Arrays.asList(...));

co tworzy 2 listy plus inne narzuty. Jeśli chodzi o miejsce, oszczędzasz UnmodifiableListopakowanie i kilka groszy. Ostatecznie oszczędności w HashSetekwiwalencie są bardziej przekonujące.

Czas zakończenia: użyj, List.ofgdy chcesz mieć listę, która się nie zmienia i Arrays.asListkiedy chcesz, aby lista mogła się zmieniać (jak pokazano powyżej).

Podsumujmy różnice między List.of i Arrays.asList

1. List.ofmoże być najlepiej stosowany, gdy zestaw danych jest mniejszy i niezmieniony, natomiast Arrays.asListmoże być najlepiej używany w przypadku dużego i dynamicznego zestawu danych.

2. List.ofzajmuje bardzo mniej miejsca narzutu, ponieważ ma implementację opartą na polach i zużywa mniej miejsca na sterty, zarówno pod względem stałego narzutu, jak i na podstawie liczby elementów. natomiast Arrays.asListzająć więcej miejsca nad głową, ponieważ podczas inicjalizacji tworzy więcej obiektów w sterty.

3. Kolekcja zwrócona przez List.ofjest niezmienna i dlatego jest bezpieczna wątkowo, podczas gdy kolekcja zwrócona przez Arrays.asListjest modyfikowalna i nie jest bezpieczna wątkowo. (Niezmienne wystąpienia kolekcji zwykle zużywają znacznie mniej pamięci niż ich zmienne odpowiedniki).

4. List.ofnie zezwala na puste elementy, podczas gdy Arrays.asListzezwala na puste elementy.

Oprócz powyższych odpowiedzi są pewne operacje na oba List::ofi Arrays::asListróżnią:

+----------------------+---------------+----------+----------------+---------------------+
|      Operations      | SINGLETONLIST | LIST::OF | ARRAYS::ASLIST | JAVA.UTIL.ARRAYLIST |
+----------------------+---------------+----------+----------------+---------------------+
|          add         |       ❌      |     ❌  |        ❌      |          ✔️          |
+----------------------+---------------+----------+----------------+---------------------+
|        addAll        |       ❌      |     ❌  |        ❌      |          ✔️          |
+----------------------+---------------+----------+----------------+---------------------+
|         clear        |       ❌      |     ❌  |        ❌      |          ✔️          |
+----------------------+---------------+----------+----------------+---------------------+
|        remove        |       ❌      |     ❌  |        ❌      |          ✔️          |
+----------------------+---------------+----------+----------------+---------------------+
|       removeAll      |       ❗️       |     ❌   |        ❗️       |          ✔️          |
+----------------------+---------------+----------+----------------+---------------------+
|       retainAll      |       ❗️       |     ❌  |        ❗️        |          ✔️          |
+----------------------+---------------+----------+----------------+---------------------+
|      replaceAll      |       ❌      |     ❌  |        ✔️       |          ✔️          |
+----------------------+---------------+----------+----------------+---------------------+
|          set         |       ❌      |     ❌  |        ✔️       |          ✔️          |
+----------------------+---------------+----------+----------------+---------------------+
|         sort         |       ✔️       |     ❌   |        ✔️      |          ✔️          |
+----------------------+---------------+----------+----------------+---------------------+
|  remove on iterator  |       ❌      |     ❌  |        ❌      |          ✔️          |
+----------------------+---------------+----------+----------------+---------------------+
| set on list-iterator |       ❌      |     ❌  |        ✔️       |          ✔️          |
+----------------------+---------------+----------+----------------+---------------------+

1. ✔️ oznacza, że ​​metoda jest obsługiwana
2. ❌ oznacza, że ​​wywołanie tej metody spowoduje zgłoszenie wyjątku UnsupportedOperationException
3. ❗️ oznacza, że ​​metoda jest obsługiwana tylko wtedy, gdy argumenty metody nie powodują mutacji, np. Collections.singletonList ("foo"). RetainAll ("foo") jest OK, ale Collections.singletonList ("foo"). RetainAll ("bar" ) zgłasza UnsupportedOperationException

Więcej o kolekcjach :: singletonList Vs. Lista