Deep Comparison Between List.of and Arrays.asList in Java: Immutability and Design Philosophy

Introduction and Background

Throughout the evolution of Java's Collections Framework, the creation of collections has undergone multiple transformations. The List.of factory method introduced in Java 9 represents a new paradigm in immutable collection design, while the traditional Arrays.asList method reflects early Java's support for mutable collections. Although both methods can create lists, they differ significantly in design philosophy and implementation details.

Mutability vs. Immutability

Arrays.asList returns a mutable list that allows element modification via the set method. For example:

List<Integer> mutableList = Arrays.asList(1, 2, 3);
mutableList.set(1, 10); // Executes successfully, list becomes [1, 10, 3]

In contrast, lists created by List.of are completely immutable, and any modification attempt throws an UnsupportedOperationException:

List<Integer> immutableList = List.of(1, 2, 3);
immutableList.set(1, 10); // Throws UnsupportedOperationException

This immutability design offers multiple advantages: thread safety, prevention of accidental modifications, and clearer data flow control.

Null Handling Mechanisms

Arrays.asList permits null elements, aligning with early Java collection design:

List<Integer> listWithNull = Arrays.asList(1, 2, null); // Created normally

However, List.of explicitly prohibits null elements, and any creation attempt containing null immediately throws a NullPointerException:

List<Integer> list = List.of(1, 2, null); // Throws NullPointerException

This strictness extends to query operations. Lists created by Arrays.asList return false when calling contains(null) (unless the list actually contains null), while lists created by List.of throw an exception in the same scenario:

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

List<Integer> listOf = List.of(1, 2, 3);
listOf.contains(null); // Throws NullPointerException

This design difference reflects modern Java's higher requirements for null safety.

Array Views vs. Data Independence

Arrays.asList returns a "view" of the underlying array, meaning the list and the original array share the same data storage:

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

While this sharing mechanism can be useful in certain scenarios, it introduces risks to data consistency. Conversely, List.of creates a completely independent data copy:

Integer[] array = {1, 2, 3};
List<Integer> list = List.of(array);
array[1] = 99;
System.out.println(list); // Outputs [1, 2, 3], list unaffected by array modification

This data independence enhances code predictability and maintainability.

Performance and Memory Considerations

From an implementation perspective, List.of is optimized for different list sizes. For small lists (e.g., 0-2 elements), it uses specialized static instances to avoid unnecessary object creation. For example, List.of() returns a shared empty list instance, while List.of(element) and List.of(e1, e2) have corresponding optimized implementations.

Arrays.asList is relatively simpler; it wraps the input array and creates a special subclass of ArrayList. This implementation, while straightforward, lacks optimizations for immutable scenarios.

Application Scenarios and Recommendations

Based on the above analysis, developers can choose the appropriate method according to specific needs:

• Use List.of when immutable collections are required, particularly in functional programming, configuration data, constant definitions, and similar contexts.
• Use Arrays.asList when quickly creating temporary mutable lists or maintaining data synchronization with existing arrays is necessary.

It is worth noting that Java 16 further strengthened support for immutable collections by introducing new collector methods like toList, making immutable collection usage more convenient.

Conclusion

List.of and Arrays.asList represent different stages and philosophies in Java collection design. The immutability, null safety, and data independence of List.of make it more suitable for modern Java development, especially in scenarios requiring high thread safety and code robustness. Meanwhile, the flexibility and backward compatibility of Arrays.asList retain its value in specific contexts. Understanding these differences enables developers to make more informed technical choices and write safer, more efficient Java code.