Streams

1. In Java 8+ you can make a stream of your int array. Call either Arrays.stream or IntStream.of.
2. Call IntStream#boxed to use boxing conversion from int primitive to Integer objects.
3. Collect into a list using Stream.collect( Collectors.toList() ). Or more simply in Java 16+, call Stream#toList().

Example:

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

In Java 16 and later:

List<Integer> list = Arrays.stream(ints).boxed().toList();

ArrayList is not the best storage for primitives such as int. ArrayList stores objects not primitives. There are libraries out there for Lists with primitives. If you really want to store all primitive int as anInteger object you will have to convert them one by one using Integer.valueOf(...) (so you don't create extra Integer instances when not needed).

While you can do this:

List<Integer> list = Arrays.asList(1, 2, 3);

You cannot do this:

int[] i = { 1, 2, 3 };
List<Integer> list = Arrays.asList(i); // this will get you List<int[]>

as an array is actually an object as well an treated as such in var-args when using primitives such as int. Object arrays works though:

List<Object> list = Arrays.asList(new Object[2]);

So something along the lines of:

int[] array = { 1, 2, 3 };
ArrayList<Integer> list = new ArrayList<Integer>(array.length);
for (int i = 0; i < array.length; i++)
  list.add(Integer.valueOf(array[i]));

In your example, it is because you can't have a List of a primitive type. In other words, List<int> is not possible.

You can, however, have a List<Integer> using the Integer class that wraps the int primitive. Convert your array to a List with the Arrays.asList utility method.

Integer[] numbers = new Integer[] { 1, 2, 3 };
List<Integer> list = Arrays.asList(numbers);

See this code run live at IdeOne.com.

Solution for Java 8. A bit longer than the Guava one, but at least you don't have to install a library.

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

//...

List<Integer> integers = Arrays.asList(1, 2, 3, 4);
List<String> strings = integers.stream().map(Object::toString)
                                        .collect(Collectors.toList());

For Java 11,

List<String> strings = integers.stream().map(Object::toString)
                                        .collect(Collectors.toUnmodifiableList());

Still no map convenience method, really?