Tutorial: Learn how to use the java.util.Arrays asList method in Java now! 🤔

In this Java 8 instructional we’ll cover how to use the Arrays.asList method in Java with a step-by-step example that demonstrates how this method works and also explains why the instance of java.util.List returned is immutable.

Java Arrays.asList Tutorial TOC

See also the parent article regarding how to convert an Array to an ArrayList in Java and also be careful not to get burned by performance issues as it pertains to autoboxing in Java.

On the right is a link to the GitHub Gist for the step-by-step review covered in the next section.

Example source code on GitHub

As per the documentation for the Arrays class, the Arrays.asList array method returns a fixed-size list backed by the specified array and does not support the add method or other list modification methods; attempts to call any mutation operations will result in an exception being thrown.

If you need a mutable list then see the follow-up tutorial that covers how to use the ArrayList constructor in Java.

Let’s get right into an example and walk through what’s happening in each step.

This article was updated on March 13, 2025.

Do you need an Interim CTO? Let’s Talk!

Hire an Interim CTO now -- schedule an appointment today to discuss your needs!
Schedule An Appointment

Java Arrays asList Example

In this step-by-step walkthrough we’ll go over how to use the Arrays.asList method and discuss the instance of List which it returns and why it doesn’t support all of the same operations as the java.util.ArrayList.

We can run the Java Arrays asList example directly from our browser using the tio.run online interpreter.

This Groovy code example relies on Java 8 API and it should be easy enough to convert this example into Java code.

Try It Online: How To Convert An Array To An ArrayList In Java
Try It Online: Arrays.asList Java Example

Step One: Import the asList static method.

The first step in this example requires that we import the Arrays.asList static method and the java.util.List class as well.

We import the java.util.Random class for the purposes of creating some random data to work with.

Step One: Script source code with a pointer to the java.util.Arrays.asList static import.
Step One: Import the java.util.Arrays.asList static method.

Step Two: Create an array of random Integer values.

In the second step we assign random Integer values to the numbers array.

We need some data to work with for this example, and an array of random Integers should be sufficient for our purposes.

Pointer to the line where we load the numbers array with random java.lang.Integer values.
Step Two: Load the numbers array with random java.lang.Integer values.

Step Three: Invoke the asList method.

Invoke the java.util.Arrays asList method and assign the result returned to List of type java.lang.Integer.

Pointer to the line where we convert the numbers array into an immutable instance of Arrays$ArrayList.
Step Three: Convert the numbers array into an immutable instance of Arrays ArrayList.

Step Four: Inspect the result.

In the fourth step we inspect the result returned by printing some of the information to console out.

We are specifically interested in the type of result returned in step three and we should also confirm that the List instance contains some random Integer values.

In Step Four: we print the result class, which is expected to be an instance of Arrays$ArrayList along with the first five entries in the result.
Step Four: Arrays.asList in Java Example

Step Five: Run the example.

In the fifth step we run the example by clicking on the play button indicated by the red pointer.

Pointer to the play button to run the Java Arrays asList example script.
Step Five: Run the Java Arrays asList example script.

Step Six: Review the output.

Review the output and note that the result is an instance of Arrays$ArrayList — this List is an immutable implementation of the List interface and if we try to modify this list an java.lang.UnsupportedOperationException runtime exception will be thrown.

Step Six: Inspect the output after running the script and note that we have an instance of an immutable Arrays$ArrayList, which contains some random integer values for the first five entries.
Step Six: Inspect the output after running the script.

Step Seven: Attempt to add an Integer to the result List.

In the seventh step we attempt to add an Integer to the result List and when we run the Groovy example script an instance of UnsupportedOperationException will be thrown because the result List is an instance of Arrays$ArrayList, which is immutable.

If we need to change the contents of the resultant List then we’ll need to convert the result into an instance of java.util.ArrayList, which is mutable.

In Step Seven we have two pointers: the top pointer directs our attention to an attempt to invoke a mutator operation on the result instance of Arrays$ArrayList, which is immutable and will cause an UnsupportedOperationException to be thrown; the bottom pointer is to the output when this script is executed and demonstrates that the expected exception was thrown.
Step Seven: An UnsupportedOperationException is thrown from the call to the Arrays.ArrayList add method.

This concludes the walk-through regarding the Java 8 Arrays asList method — the tutorial conclusion follows.

Java java.util.Arrays asList Performance

The asList method in the java.util.Arrays returns an instance of java.util.Arrays$ArrayList (Arrays.ArrayList) which is read-only and is also backed directly by the array passed to the asList method.

The Arrays$ArrayList class differs from the java.util.ArrayList class in that it is read only and since mutator operations are unsupported invoking any of these methods will result an an UnsupportedOperationException being thrown.

Given that the Arrays.ArrayList class is read only, it will be unsuitable for use in situations we need to change the contents.

Converting from a Java array to an Arrays.ArrayList involves a single step and hence it performs very well, boasting an O(1) efficiency.

The Arrays$ArrayList static inner class Java 11 source code with pointers to the backing array -- note that instances of the Arrays$ArrayList are immutable and attempts to invoke any of the mutator methods will result in an UnsupportedOperationException being thrown.
Arrays asList Java 11 source code for the Arrays$ArrayList static inner class.

I’ve included a direct link to the Java 11 project source code for the Arrays$ArrayList static inner class on GitHub on the right-hand side of this page.

The Arrays$ArrayList source code on GitHub.

About This Guide

This instructional is a content experiment based on research from the StackOverflow post entitled How to convert int[] into List<Integer> in Java? along with some observations discovered while doing keyword research using SEMrush.

Other options are available as well — refer to the parent article regarding how to turn an array into an ArrayList along with the other guides listed in the see also section below.

See Also

  1.  Tutorial: Learn how to convert an array to an ArrayList in Java!
  2. This instructional demonstrates how to use the Java ArrayList and stream method to transform an array of primitives efficiently.
  3. Learn how to convert a Java array into an ArrayList via the ArrayList constructor here!
  4. Learn how to use the Guava Lists.newArrayList method in this guide!
  5. A tutorial regarding how to transform an array to an ArrayList stream Java can be found here.
  6. Adding elements to a List in Java is easy in this introductory article geared toward beginner programmers!
  7. Introduction to the Java Programming Language
  8. Read about the discovery of a performance problem due to autoboxing in Java here.
author avatar
ThosPFuller
I am a software engineer based in Northern Virginia (USA) and this website focuses on content engineering, web development, Technical SEO, Search Engine Optimization (SEO).
See Full Bio
social network icon

Leave a Reply