В Java 9 появились новые фабричные методы для списков List.of:

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

В чем разница между предыдущим и новым вариантом? То есть в чем разница между этим:

Arrays.asList(1, 2, 3);

и это:

List.of(1, 2, 3);

Arrays.asListвозвращает изменяемый список, в то время как список, возвращаемый функцией,List.of является неизменным :

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.asListдопускает нулевые элементы, а List.ofне:

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

contains по-другому ведет себя с нулями:

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.asListвозвращает представление переданного массива, поэтому изменения в массиве также будут отражены в списке. Ибо List.ofэто неправда:

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]

Различия между Arrays.asListиList.of

См. JavaDocs и доклад Стюарта Маркса (или его предыдущие версии).

Для примеров кода я буду использовать следующее:

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

Структурная неизменность (или: неизменяемость)

Любая попытка структурных изменений List.ofприведет к созданию файла UnsupportedOperationException. Сюда входят такие операции, как добавление , установка и удаление . Однако вы можете изменить содержимое объектов в списке (если объекты не являются неизменяемыми), чтобы список не был «полностью неизменяемым».

То же самое и с неизменяемыми списками, созданными с помощью Collections.unmodifiableList. Только этот список является представлением исходного списка, поэтому он может измениться, если вы измените исходный список.

Arrays.asListне является полностью неизменяемым, для него нет ограничений set.

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

Точно так же изменение массива поддержки (если вы его удерживаете) изменит список.

Структурная неизменяемость имеет множество побочных эффектов, связанных с защитным кодированием, параллелизмом и безопасностью, которые выходят за рамки этого ответа.

Нулевая враждебность

List.ofи любая коллекция, начиная с Java 1.5, не допускает использования nullв качестве элемента. Попытка пройтиnull как элемент или даже поиск приведет к созданию файла NullPointerException.

Поскольку Arrays.asListэто коллекция из 1.2 (платформа коллекций), она позволяет nulls.

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

Сериализованная форма

Поскольку List.ofон был представлен в Java 9 и списки, созданные этим методом, имеют свою собственную (двоичную) сериализованную форму, они не могут быть десериализованы в более ранних версиях JDK (нет двоичной совместимости ). Однако вы можете де / сериализовать, например, с помощью JSON.

тождественность

Arrays.asListвнутренние вызовы new ArrayList, что гарантирует ссылочное неравенство.

List.ofзависит от внутренней реализации. Возвращенные экземпляры могут иметь ссылочное равенство, но поскольку это не гарантируется, вы не можете на это полагаться.

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

Стоит отметить, что списки равны (через List.equals), если они содержат одинаковые элементы в одном порядке, независимо от того, как они были созданы или какие операции они поддерживают.

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

Реализация (предупреждение: детали могут изменяться в зависимости от версии)

Если количество элементов в списке List.ofравно 2 или меньше, элементы сохраняются в полях специализированного (внутреннего) класса. Примером может служить список, в котором хранятся 2 элемента (частичный источник):

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

В противном случае они хранятся в массиве аналогично Arrays.asList.

Эффективность времени и пространства

В List.ofреализации , которые являются полями на основе (размером <2) немного быстрее выполнить на некоторых операциях. Например, size()может возвращать константу без извлечения длины массива и contains(E e)не требует дополнительных затрат на итерацию.

Создание неизменяемого списка с помощью List.ofтакже выполняется быстрее. Сравните приведенный выше конструктор с двумя ссылочными назначениями (и даже с одним для произвольного количества элементов) для

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

который создает 2 списка плюс другие накладные расходы. Что касается места, вы экономите UnmodifiableListобертку плюс несколько копеек. В конечном итоге экономия в HashSetэквиваленте более убедительна.

Время заключения: используйте, List.ofкогда вам нужен список, который не меняется, и Arrays.asListкогда вам нужен список, который может изменяться (как показано выше).

Пусть суммировать различия между List.of и Arrays.asList

1. List.ofлучше всего использовать, когда набор данных меньше и не изменяется, а Arrays.asListлучше всего использовать в случае большого и динамического набора данных.

2. List.ofзанимают очень меньше служебного пространства, потому что он реализован на основе полей и потребляет меньше места в куче, как с точки зрения фиксированных служебных данных, так и для отдельных элементов. в то время как Arrays.asListзанимают больше служебного пространства, потому что при инициализации он создает больше объектов в куче.

3. Коллекция, возвращаемая List.ofобъектом, является неизменной и, следовательно, потокобезопасной, в то время как Коллекция, возвращаемая Arrays.asListобъектом, является изменяемой и не потокобезопасной. (Неизменяемые экземпляры коллекций обычно потребляют гораздо меньше памяти, чем их изменяемые аналоги.)

4. List.ofне допускает нулевые элементы, а Arrays.asListдопускает нулевые элементы.

Помимо приведенных выше ответов, существуют определенные операции, по которым оба List::ofи Arrays::asListразличаются:

+----------------------+---------------+----------+----------------+---------------------+
|      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. ✔️ означает, что метод поддерживается
2. ❌ означает, что вызов этого метода вызовет исключение UnsupportedOperationException
3. ❗️ означает, что метод поддерживается только в том случае, если аргументы метода не вызывают мутации, например, Collections.singletonList ("foo"). KeepAll ("foo") в порядке, но Collections.singletonList ("foo"). KeepAll ("bar" ) выдает исключение UnsupportedOperationException

Подробнее о Коллекциях :: singletonList Vs. Список