What is the difference between List.of and Arrays.asList?

Java 9 introduced new factory methods for lists, List.of:

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

What's the difference between the previous and the new option? That is, what's the difference between this:

Arrays.asList(1, 2, 3);

and this:

List.of(1, 2, 3);

Arrays.asList returns a mutable list while the list returned by List.of is immutable:

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 allows null elements while List.of doesn't:

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

contains behaves differently with nulls:

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 returns a view of the passed array, so the changes to the array will be reflected in the list too. For List.of this is not true:

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]

Difference between Arrays.asList(array) Vs. ArrayList(Arrays.asList , In java what is a difference between List Vs. ArrayList? In other words, have you ever wondered what is the difference between Arrays. What is a difference between List and Arraylist? Answer is very simple. List is an interface, ArrayList is a class that implements List. Below are the list of all available methods for ArrayList. Take a look at below Java program which clearly explains you the difference between the same.

The differences between Arrays.asList and List.of

See the JavaDocs and this talk by Stuart Marks (or previous versions of it).

I'll be using the following for the code examples:

List<Integer> listOf = List.of(...);
List<Integer> asList = Arrays.asList(...);
List<Integer> unmodif = Collections.unmodifiableList(asList);
Structural immutability (Or: unmodifiability)

Any attempt to structurally change List.of will result in an UnsupportedOperationException. That includes operations such as add, set and remove. You can, however, change the contents of the objects in the list (if the objects are not immutable), so the list is not "completely immutable".

This is the same fate for unmodifiable lists created with Collections.unmodifiableList. Only this list is a view of the original list, so it can change if you change the original list.

Arrays.asList is not completely immutable, it does not have a restriction on set.

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

Similarly, changing the backing array (if you hold it) will change the list.

Structural immutability comes with many side-effects related to defensive coding, concurrency and security which are beyond the scope of this answer.

Null hostility

List.of and any collection since Java 1.5 do not allow null as an element. Attempting to pass null as an element or even a lookup will result in a NullPointerException.

Since Arrays.asList is a collection from 1.2 (the Collections Framework), it allows nulls.

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

Since List.of has been introduced in Java 9 and the lists created by this method have their own (binary) serialized form, they cannot be deserialized on earlier JDK versions (no binary compatibility). However, you can de/serialize with JSON, for example.


Arrays.asList internally calls new ArrayList, which guarantees reference inequality.

List.of depends on internal implementation. The instances returned can have reference equality, but since this is not guaranteed you can not rely on it.

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

Worth mentioning that lists are equal (via List.equals) if they contain the same elements in the same order, regardless of how they were created or what operations they support.

asList.equals(listOf); // true i.f.f. same elements in same order
Implementation (warning: details can change over versions)

If the number of elements in the list of List.of is 2 or less, the elements are stored in fields of a specialized (internal) class. An example is the list that stores 2 elements (partial source):

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

Otherwise they are stored in an array in a similar fashion to Arrays.asList.

Time and Space efficiency

The List.of implementations which are field-based (size<2) perform slightly faster on some operations. As examples, size() can return a constant without fetching the array length, and contains(E e) does not require iteration overhead.

Constructing an unmodifiable list via List.of is also faster. Compare the above constructor with 2 reference assignments (and even the one for arbitrary amount of elements) to


which creates 2 lists plus other overhead. In terms of space, you save the UnmodifiableList wrapper plus some pennies. Ultimately, the savings in the HashSet equivalent are more convincing.

Conclusion time: use List.of when you want a list that doesn't change and Arrays.asList when you want a list that can change (as shown above).

Arrays asList() method in Java with Examples, The asList() method of java.util.Arrays class is used to return a fixed-size list backed by the specified array. This method acts as bridge between array-based and  There are 4 main differences: Arrays.asList returns a mutable list while the list returned by List.of is immutable: 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. Arrays.asList allows null elements while List.of doesn't:

Let summarize the differences between List.of and Arrays.asList

  1. List.of can be best used when data set is less and unchanged, while Arrays.asList can be used best in case of large and dynamic data set.

  2. List.of take very less overhead space because it has field-based implementation and consume less heap space, both in terms of fixed overhead and on a per-element basis. while Arrays.asList take more overhead space because while initialization it creates more objects in heap.

  3. Collection returned by List.of is immutable and hence thread-safe while Collection returned by Arrays.asList is mutable and not thread safe. (Immutable collection instances generally consume much less memory than their mutable counterparts.)

  4. List.of doesn't allow null elements while Arrays.asList allows null elements.

Top 10 Mistakes Java Developers Make, This list summarizes the top 10 mistakes that Java developers frequently make. can accept a Collection type, which is also a super type for java.util.Arrays.​ArrayList . #2. One of the key differences between Hashtable and HashMap is that  Difference between Arrays.asList(array) and new ArrayList (Arrays.asList(array)) in Java May 26, 2020 May 26, 2020 There are significant differences between Arrys.asList(array) and new ArrayList (Arrays.asList(array)) because the result from Arrys.asList(array) is NOT the type of java.util.ArrayList .

Apart from the above answers there are certain operations on which both List::of and Arrays::asList differ:

|          add         |       ❌       |     ❌    |        ❌       |          ✔️          |
|        addAll        |       ❌       |     ❌    |        ❌       |          ✔️          |
|         clear        |       ❌       |     ❌    |        ❌       |          ✔️          |
|        remove        |       ❌       |     ❌    |        ❌       |          ✔️          |
|       removeAll      |       ❗️       |     ❌    |        ❗️       |          ✔️          |
|       retainAll      |       ❗️       |     ❌    |        ❗️       |          ✔️          |
|      replaceAll      |       ❌       |     ❌    |        ✔️       |          ✔️          |
|          set         |       ❌       |     ❌    |        ✔️       |          ✔️          |
|         sort         |       ✔️       |     ❌    |        ✔️       |          ✔️          |
|  remove on iterator  |       ❌       |     ❌    |        ❌       |          ✔️          |
| set on list-iterator |       ❌       |     ❌    |        ✔️       |          ✔️          |
  1. ✔️ means the method is supported
  2. ❌ means that calling this method will throw an UnsupportedOperationException
  3. ❗️ means the method is supported only if the method's arguments do not cause a mutation, e.g. Collections.singletonList("foo").retainAll("foo") is OK but Collections.singletonList("foo").retainAll("bar")throws an UnsupportedOperationException

More about Collections::singletonList Vs. List::of

java.util.Arrays.asList java code examples, Best Java code snippets using java.util.Arrays.asList (Showing top 20 results out isEmpty()) { for (int s = 0; s < node_.size(); s++) { List<Double> penaltys = Arrays. Comparator<Integer>() { @Override public int compare(Integer o1, Integer  In line 2, Arrays.asList(ia) returns a List reference of inner class object defined within Arrays, which is also called ArrayList but is private and only extends AbstractList. This means what returned from Arrays.asList(ia) is a class object different from what you get from new ArrayList<Integer>.

What is difference between Arrays.asList and normal arraylist?, First, let's see what this does: Arrays.asList(ia) It takes an array ia and creates a wrapper that implements List<Integer> , which makes the original array available​  The primary difference between List and ArrayList is that List is an interface and ArrayList is a class. Let us study the difference between the List and ArrayList with the help of comparison chart shown below.

Java Compare Two Lists, The List interface in Java provides methods to be able to compare two public static void main(String[] args) { List<String> listOne = Arrays. What is the difference between List.of and Arrays.asList? Hot Network Questions Is there any food a nomad in a carriage-like transport can easily live on?

Java.util.Arrays.asList() Method, asList(T a) returns a fixed-size list backed by the specified array. (Changes to the returned list "write through" to the array.) This method acts as bridge between​  The java.util.Arrays.asList(T a) returns a fixed-size list backed by the specified array. (Changes to the returned list "write through" to the array.) This method acts as bridge between array-based and collection-based APIs, Declaration. Following is the declaration for java.util.Arrays.asList() method. public static <T> List<T> asList(T

  • See also this talk by Stuart "Beaker" Marks.
  • @user1803551 Though I understand your frustration, this reasoning might set a really unwanted precedent. A lot of questions here have an answer that's 'clearly stated' (depending on how one defines this). I'd urge you to bring this discussion to meta but I'm pretty sure such a discussion should already exist (and I'm hoping someone can find it and link it :-)
  • @user1803551 Javadocs do not mention the difference between implementation details of these two methods (like space consumption or performance). I think people would like to know these details too.
  • @ZhekaKozlov The accepted and super-upvoted answer doesn't either. What does that tell you about the accepted standards? It even has less information than in the docs (serialization, identity, ordering). If anything, file a request to OpenJDK to add that info.
  • This question is being discussed on meta.
  • For a list to behave differently based on how it's constructed doesn't seem very object oriented to me. Maybe if List.of returned an ImmutableList type, this would make sense. This is a very leaky abstraction here.
  • I'm not a Java developer, so take it as a casual observation. There's possibly a good reason for the behavior to differ, but if I had a method returning a List<Integer> like the example, the interface wouldn't be sufficient for me to know if I'll get a runtime exception if I check it for nulls. Likewise, a change in that methods implementation could affect code distant from the call site of my method if that check happens elsewhere. @Nicolai
  • @SandyChapman this might be unexpected behaviour to some (or most?), but it is documented behaviour. From the List.contains(Object o)'s javadoc : "Throws [...] NullPointerException - if the specified element is null and this list does not permit null elements (optional)". Or from the interface's lenghty introduction that few read : "Some collection implementations have restrictions on the elements that they may contain"
  • @Aaron well at least it's a well documented leaky abstraction :)
  • @Sandy Chapman: List.of does return some ImmutableList type, its actual name is just a non-public implementation detail. If it was public and someone cast it to List again, where was the difference? Where is the difference to Arrays.asList, which returns a non-public List implementation, that throws an exception when attempting add or remove, or the list returned by Collections.unmodifiableList which allows no modification at all? It’s all about contracts specified in the List interface. The Collections interfaces with optional methods always were impure OOP since Java 1.2…
  • For people wondering why this answer exists, see this.
  • Arrays.asList is not fully mutable. asList.add(1); throws an UnsupportedOperationException.