Java 9 ha introdotto nuovi metodi di fabbrica per gli elenchi, List.of:

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

Qual è la differenza tra la precedente e la nuova opzione? Cioè, qual è la differenza tra questo:

Arrays.asList(1, 2, 3);

e questo:

List.of(1, 2, 3);

Arrays.asListrestituisce un elenco modificabile mentre l'elenco restituito da List.ofè immutabile :

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.asListconsente elementi nulli mentre List.ofno:

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

contains si comporta diversamente con i 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.asListrestituisce una vista dell'array passato, quindi anche le modifiche all'array si rifletteranno nell'elenco. Per List.ofquesto non è vero:

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]

Le differenze tra Arrays.asListeList.of

Vedi i JavaDocs e questo discorso di Stuart Marks (o versioni precedenti di esso).

Userò quanto segue per gli esempi di codice:

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

Immutabilità strutturale (o: immodificabilità)

Qualsiasi tentativo di cambiare strutturalmenteList.of si tradurrà in un UnsupportedOperationException. Ciò include operazioni come aggiungere , impostare e rimuovere . È tuttavia possibile modificare il contenuto degli oggetti nell'elenco (se gli oggetti non sono immutabili), quindi l'elenco non è "completamente immutabile".

Questo è lo stesso destino per gli elenchi non modificabili creati con Collections.unmodifiableList. Solo questo elenco è una visualizzazione dell'elenco originale, quindi può cambiare se si modifica l'elenco originale.

Arrays.asListnon è completamente immutabile, non ha limitazioni set.

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

Allo stesso modo, cambiando l'array di supporto (se lo tieni premuto) cambierà l'elenco.

L'immutabilità strutturale presenta molti effetti collaterali relativi alla codifica difensiva, alla concorrenza e alla sicurezza che esulano dallo scopo di questa risposta.

Nulla ostilità

List.ofe qualsiasi raccolta a partire da Java 1.5 non consente nullcome elemento. Il tentativo di passare nullcome elemento o anche una ricerca risulterà in un file NullPointerException.

Poiché Arrays.asListè una raccolta da 1.2 (il framework delle raccolte), consente nulls.

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

Modulo serializzato

Poiché List.ofè stato introdotto in Java 9 e gli elenchi creati con questo metodo hanno il loro formato serializzato (binario), non possono essere deserializzati nelle versioni precedenti di JDK (nessuna compatibilità binaria ). Tuttavia, puoi de / serializzare con JSON, ad esempio.

Identità

Arrays.asListinternamente chiama new ArrayList, che garantisce la disuguaglianza di riferimento.

List.ofdipende dall'implementazione interna. Le istanze restituite possono avere l'uguaglianza dei riferimenti, ma poiché ciò non è garantito non puoi fare affidamento su di essa.

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

Vale la pena ricordare che le liste sono uguali (tramite List.equals) se contengono gli stessi elementi nello stesso ordine, indipendentemente da come sono state create o da quali operazioni supportano.

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

Implementazione (avviso: i dettagli possono cambiare rispetto alle versioni)

Se il numero di elementi nell'elenco di List.ofè 2 o inferiore, gli elementi vengono memorizzati in campi di una classe specializzata (interna). Un esempio è l'elenco che memorizza 2 elementi (sorgente parziale):

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

Altrimenti vengono archiviati in una matrice in modo simile a Arrays.asList.

Efficienza nel tempo e nello spazio

Le List.ofimplementazioni basate sul campo (dimensione <2) sono leggermente più veloci su alcune operazioni. Ad esempio, size()può restituire una costante senza recuperare la lunghezza dell'array e contains(E e)non richiede un overhead di iterazione.

Anche la costruzione di un elenco non modificabile tramite List.ofè più veloce. Confronta il costruttore precedente con 2 assegnazioni di riferimento (e anche quella per quantità arbitrarie di elementi) con

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

che crea 2 liste più altre spese generali. In termini di spazio, risparmi il UnmodifiableListwrapper più qualche centesimo. In definitiva, i risparmi HashSetnell'equivalente sono più convincenti.

Tempo di conclusione: usa List.ofquando vuoi un elenco che non cambia e Arrays.asListquando vuoi un elenco che può cambiare (come mostrato sopra).

Riassumiamo le differenze tra List.of e Arrays.asList

1. List.ofpuò essere utilizzato al meglio quando il set di dati è inferiore e invariato, mentre Arrays.asListpuò essere utilizzato al meglio in caso di set di dati ampio e dinamico.

2. List.ofoccupa molto meno spazio di overhead perché ha un'implementazione basata sul campo e consuma meno spazio di heap, sia in termini di overhead fisso che su base per elemento. mentre Arrays.asListoccupa più spazio in testa perché durante l'inizializzazione crea più oggetti nell'heap.

3. La raccolta restituita da List.ofè immutabile e quindi thread-safe mentre la raccolta restituita da Arrays.asListè modificabile e non thread-safe. (Le istanze di raccolta immutabili generalmente consumano molta meno memoria rispetto alle loro controparti mutabili.)

4. List.ofnon consente elementi nulli mentre Arrays.asListconsente elementi nulli .

Oltre alle risposte precedenti ci sono alcune operazioni su cui entrambi List::ofe Arrays::asListdifferiscono:

+----------------------+---------------+----------+----------------+---------------------+
|      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. ✔️ significa che il metodo è supportato
2. ❌ significa che la chiamata a questo metodo genererà un'eccezione UnsupportedOperationException
3. ❗️ significa che il metodo è supportato solo se gli argomenti del metodo non causano una mutazione, ad es. Collections.singletonList ("foo"). KeepAll ("foo") è OK ma Collections.singletonList ("foo"). KeepAll ("bar" ) genera un'eccezione UnsupportedOperationException

Ulteriori informazioni sulle collezioni :: singletonList vs. Lista di