将基础类型数组转为List

1. Overview

In this short tutorial, we’ll see 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’ll 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 want to convert that array to a List (List). An intuitive first attempt could be:

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

We might expect auto-boxing to work with arrays of primitives. However, this instinctive belief isn’t true.

If we attempt to compile this code, it throws a compilation error:

incompatible types: inference variable T has incompatible bounds
    equality constraints: java.lang.Integer 
    lower bounds: int[]

This is because 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>31.0.1-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.12.0</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.