Java 9 introduziu novos métodos de fábrica para listas List.of:

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

Qual é a diferença entre a opção anterior e a nova? Ou seja, qual é a diferença entre isso:

Arrays.asList(1, 2, 3);

e isto:

List.of(1, 2, 3);

Arrays.asListretorna uma lista mutável enquanto a lista retornada por List.ofé imutável :

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.asListpermite elementos nulos enquanto List.ofnão:

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

contains se comporta de maneira diferente com nulos:

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.asListretorna uma visão do array passado, então as mudanças no array serão refletidas na lista também. Pois List.ofisso não é verdade:

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]

As diferenças entre Arrays.asListeList.of

Veja os JavaDocs e esta palestra de Stuart Marks (ou versões anteriores).

Usarei o seguinte para os exemplos de código:

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

Imutabilidade estrutural (Ou: inalterabilidade)

Qualquer tentativa de mudança estruturalList.of resultará em um UnsupportedOperationException. Isso inclui operações como adicionar , definir e remover . Você pode, entretanto, alterar o conteúdo dos objetos na lista (se os objetos não forem imutáveis), para que a lista não seja "completamente imutável".

Este é o mesmo destino para listas não modificáveis ​​criadas com Collections.unmodifiableList. Apenas esta lista é uma visualização da lista original, portanto, ela pode mudar se você alterar a lista original.

Arrays.asListnão é completamente imutável, não tem uma restrição sobre set.

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

Da mesma forma, alterar a matriz de apoio (se você a mantiver) mudará a lista.

A imutabilidade estrutural vem com muitos efeitos colaterais relacionados à codificação defensiva, simultaneidade e segurança que estão além do escopo desta resposta.

Hostilidade nula

List.ofe qualquer coleção desde Java 1.5 não permite nullcomo um elemento. A tentativa de passar nullcomo um elemento ou mesmo uma pesquisa resultará em um NullPointerException.

Como Arrays.asListé uma coleção de 1.2 (o Framework de coleções), ele permite nulls.

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

Formulário serializado

Como List.offoi introduzido no Java 9 e as listas criadas por esse método têm sua própria forma serializada (binária), elas não podem ser desserializadas em versões anteriores do JDK (sem compatibilidade binária ). No entanto, você pode cancelar / serializar com JSON, por exemplo.

Identidade

Arrays.asListchamadas internamente new ArrayList, o que garante a desigualdade de referência.

List.ofdepende da implementação interna. As instâncias retornadas podem ter igualdade de referência, mas como isso não é garantido, você não pode confiar nela.

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

Vale ressaltar que as listas são iguais (via List.equals) se contiverem os mesmos elementos na mesma ordem, independentemente de como foram criadas ou das operações que suportam.

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

Implementação (aviso: os detalhes podem mudar nas versões)

Se o número de elementos na lista de List.offor 2 ou menos, os elementos serão armazenados em campos de uma classe especializada (interna). Um exemplo é a lista que armazena 2 elementos (fonte parcial):

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

Caso contrário, eles são armazenados em uma matriz de maneira semelhante a Arrays.asList.

Eficiência de tempo e espaço

As List.ofimplementações baseadas em campo (tamanho <2) têm um desempenho ligeiramente mais rápido em algumas operações. Como exemplos, size()pode retornar uma constante sem buscar o comprimento do array e contains(E e)não requer sobrecarga de iteração.

Construir uma lista não modificável via List.oftambém é mais rápido. Compare o construtor acima com 2 atribuições de referência (e até mesmo aquele para quantidade arbitrária de elementos) para

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

que cria 2 listas mais outra sobrecarga. Em termos de espaço, você economiza o UnmodifiableListinvólucro e alguns centavos. Em última análise, a economia no HashSetequivalente é mais convincente.

Tempo de conclusão: use List.ofquando quiser uma lista que não muda e Arrays.asListquando quiser uma lista que pode mudar (como mostrado acima).

Vamos resumir as diferenças entre List.of e Arrays.asList

1. List.ofpode ser usado melhor quando o conjunto de dados é menor e inalterado, enquanto Arrays.asListpode ser usado melhor no caso de um conjunto de dados grande e dinâmico.

2. List.ofocupa muito menos espaço de sobrecarga porque tem implementação baseada em campo e consome menos espaço de heap, tanto em termos de sobrecarga fixa quanto em uma base por elemento. enquanto Arrays.asListocupa mais espaço de overhead porque durante a inicialização cria mais objetos no heap.

3. A coleção retornada por List.ofé imutável e, portanto, segura para threads, enquanto a coleção retornada por Arrays.asListé mutável e não segura para threads. (Instâncias de coleção imutáveis ​​geralmente consomem muito menos memória do que suas contrapartes mutáveis.)

4. List.ofnão permite elementos nulos enquanto Arrays.asListpermite elementos nulos .

Além das respostas acima, existem certas operações nas quais List::ofe Arrays::asListdiferem:

+----------------------+---------------+----------+----------------+---------------------+
|      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 que o método é compatível
2. ❌ significa que chamar este método lançará uma exceção UnsupportedOperationException
3. ❗️ significa que o método é suportado apenas se os argumentos do método não causam uma mutação, por exemplo, Collections.singletonList ("foo"). RetêmAll ("foo") está OK, mas Collections.singletonList ("foo"). RetêmAll ("bar") ) lança uma UnsupportedOperationException

Mais sobre Coleções :: singletonList vs. Lista de