Convert an Array of Primitives to a List

1. Overview

In this short tutorial, we'll show how to convert an array of primitives to a List of objects of the corresponding type. Typically, we might try to use autoboxing in Java. However, as we're going to see in the next section, our intuition of how autoboxing works can often be erroneous.

2. Problem

Let's begin with the definition of the problem. We have an array of primitives (int[]), and we desire to convert that array to a List (List<Integer>). An intuitive first attempt could be:

int[] input = new int[]{1,2,3,4};
List<Integer> output = Arrays.asList(input);

Unfortunately, this won't compile due to type incompatibility. We might expect autoboxing to work with arrays of primitives. However, this instinctive belief isn't true.

Autoboxing only happens for a single element (for example from int to Integer). There is no automatic conversion from an array of primitive types to an array of their boxed reference types (for example from int[] to Integer[]).

Let's start to implement a few solutions to this problem.

3. Iteration

Since autoboxing works with single primitive elements, a simple solution is to just iterate over the elements of the array and add them to the List one by one:

int[] input = new int[]{1,2,3,4};
List<Integer> output = new ArrayList<Integer>();
for (int value : input) {
    output.add(value);
}

We have solved the problem, but the solution is quite verbose. This brings us to the next implementation.

4. Streams

Since Java 8, we can use the Stream API. We can provide a one-line solution using a Stream:

int[] input = new int[]{1,2,3,4};
List<Integer> output = Arrays.stream(input).boxed().collect(Collectors.toList());

Alternatively, we could use IntStream:

int[] input = new int[]{1,2,3,4};
List<Integer> output = IntStream.of(input).boxed().collect(Collectors.toList());

This certainly looks a lot nicer. Next, we'll look at a couple of external libraries.

5. Guava

The Guava library provides a wrapper around this problem. Let's start by adding the Maven dependency:

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>29.0-jre</version>
    <type>bundle</type>
</dependency>

We can use Ints.asList(), with similar utility classes for the other primitive types:

int[] input = new int[]{1,2,3,4};
List<Integer> output = Ints.asList(input);

6. Apache Commons

Another library is the Apache Commons Lang. Again, let's add the Maven dependency for this library:

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.10</version>
</dependency>

More precisely, we use the ArrayUtils class:

int[] input = new int[]{1,2,3,4};
Integer[] outputBoxed = ArrayUtils.toObject(input);
List<Integer> output = Arrays.asList(outputBoxed);

7. Conclusion

We now have a few options in our toolbox to convert an array of primitives to a List. As we have seen, autoboxing only happens for single elements. In this tutorial, we've seen several solutions for applying the conversion.

As always, the full source code of the article is available over on GitHub.