How to convert an int[] array to a List?

I expected this code to disp开发者_Go百科lay true:

int[] array = {1, 2};
System.out.println(Arrays.asList(array).contains(1));

---

The method Arrays.asList(T ...) is, when generics are erased and varargs are transformed, actually equal to a method of type Arrays.ofList(Object[]) (which is the, binary equivalent, JDK 1.4 version of the same Method).

An array of primitives is an Object (see also this question), but not an Object[], so the compiler thinks you are using the varargs version and generates an Object array around your int array. You could illustrate what's happening by adding an extra step:

int[] array = {1, 2};
List<int[]> listOfArrays = Arrays.asList(array);
System.out.println(listOfArrays.contains(1));

This compiles and is equivalent to your code. It also obviously returns false.

The compiler translates varargs calls into calls with a single array, so calling a varargs method that expects parameters T ... with parameters T t1, T t2, T t3 is equivalent to calling it with new T[]{t1, t2, t3} but the special case here is that varargs with primitives will be autoboxed before the array is created if the method needs an object array. So the compiler thinks the int array is passed in as a single Object and creates a single element array of type Object[], which it passes to asList().

So here's the above code once again, the way the compiler implements it internally:

int[] array = {1, 2};
// no generics because of type erasure
List listOfArrays = Arrays.asList(new Object[]{array});
System.out.println(listOfArrays.contains(1));

Here are some good and bad ways to call Arrays.asList() with int values:

// These versions use autoboxing (which is potentially evil),
// but they are simple and readable

// ints are boxed to Integers, then wrapped in an Object[]
List<Integer> good1 = Arrays.asList(1,2,3);
// here we create an Integer[] array, and fill it with boxed ints
List<Integer> good2 = Arrays.asList(new Integer[]{1,2,3});

// These versions don't use autoboxing,
// but they are very verbose and not at all readable:

// this is awful, don't use Integer constructors
List<Integer> ugly1 = Arrays.asList(
    new Integer(1),new Integer(2),new Integer(3)
);
// this is slightly better (it uses the cached pool of Integers),
// but it's still much too verbose
List<Integer> ugly2 = Arrays.asList(
    Integer.valueOf(1), Integer.valueOf(2), Integer.valueOf(3)
);

// And these versions produce compile errors:
// compile error, type is List<int[]>
List<Integer> bad1 = Arrays.asList(new int[]{1,2,3});
// compile error, type is List<Object>
List<Integer> bad2 = Arrays.asList(new Object[]{1,2,3});

Reference:

• Java Tutorial > Classes and Objects > Passing Information to a Method or a Constructor > Varargs
• Arrays.asList(T ...)

---

But to actually solve your problem in a simple way:

There are some library solutions in Apache Commons / Lang (see Bozho's answer) and in Google Guava:

• Ints.contains(int[], int) checks whether an array of ints contains a given int
• Ints.asList(int ...) creates a List of Integers from an int array

---

The Arrays.asList(array) will result in a singleton list of an int[].

It works as you expect if you change int[] to Integer[]. Don't know if that helps you though.

---

Arrays.asList(ArrayUtils.toObjectArray(array))

(ArrayUtils is from commons-lang)

But if you want to just call contains there is no need of that. Simply use Arrays.binarySearch(..) (sort the array first)

---

This

System.out.println(Arrays.asList(array).contains(array));

returns true.

---

It seems like your understanding of Arrays.asList(T... a) is wrong. You wouldn't be the first person to make an assumption as to how it works.

Try it with

System.out.println(Arrays.asList(1, 2).contains(1));

---

Autoboxing just doesn't work the way you want it to in this case. The following code may be a bit verbose, but does the job of converting an int array to a list:

List<Integer> list = new ArrayList<Integer>(array.length);
for (int value : array) {
    list.add(value);
}

---

The following code displays true:

Integer[] array = {1, 2};
System.out.println(Arrays.asList(array).contains(1));

(Your version fails, since Int's not beeing objects, but Int[] is an object. Therefor you will call asList(T... a) with one element beeing a Collection, since it is not possible to have an Collection a.)

---

When you call

Arrays.asList(array)

on your array of primitives, you get a List instance containing one object: an array of int values! You have to first convert the array of primitives into an array of objects, as @Bozho suggests in his answer.

---

If you only want to check whether the array contains certain element just iterate over array and search for element. This will take o(n/2). All other solutions are less effective. Any method that copies array to list must iterate over array and therefore this operation only requires n atomic assignments.

---

I dont think there is a method call you could use. Try it like this

List<Integer> list = new ArrayList<Integer>();
  for (int index = 0; index < array.length; index++)
  {
    list.add(array[index]);
  }