Cómo convertir una matriz int [] a una lista?

Question

esperaba que este código para mostrar true:

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

Answer 1

El Arrays.asList(array) se traducirá en una lista unitaria de un int[].

Funciona como espera si cambia int[] a Integer[]. No sé si eso te ayuda.

Answer 2

Creo que no es un método de llamada que podría utilizar. Inténtelo como esto

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

Answer 3

Arrays.asList(ArrayUtils.toObjectArray(array)) 

(ArrayUtils es de commons-lang)

Pero si sólo quiere llamar contains no hay necesidad de ello. Sólo tiene que utilizar Arrays.binarySearch(..) (ordenar primero la matriz)

Answer 4

Este

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

vuelve true.

Answer 5

El método Arrays.asList(T ...) es, cuando se eliminan los genéricos y se transforman varargs, realmente igual a un método del tipo Arrays.ofList(Object[]) (que es el equivalente binario, versión JDK 1.4 del mismo método).

Un conjunto de primitivas es un Object (véase también this question), pero no una Object[], por lo que el compilador piensa que está utilizando la versión varargs y genera una serie de objetos en torno a la matriz int. Puede ilustrar lo que está sucediendo agregando un paso adicional:

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

Esto compila y es equivalente a su código. También obviamente devuelve falso.

El compilador traduce varargs llamadas en las llamadas con una sola matriz, por lo que llama a un método varargs que espera parámetros T ... con parámetros T t1, T t2, T t3 es equivalente a llamar con new T[]{t1, t2, t3} pero el caso especial aquí es que varargs con primitivas se autoboxed antes de la array se crea si el método necesita una matriz de objetos. Por lo tanto, el compilador cree que la matriz int se transfiere como un único objeto y crea una única matriz de elementos de tipo Object[], que pasa a asList().

Así que aquí está el código anterior, una vez más, la forma en que el compilador implementa internamente:

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

Estas son algunas buenas y malas maneras de llamar Arrays.asList() con valores int:

// 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}); 

Referencia :

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

---

Pero para realmente resolver su problema de una manera sencilla:

Hay algunas soluciones de biblioteca en Apache Commons/Lang (ver Bozho's answer) y en Google Guava:

• Ints.contains(int[], int) comprueba si una matriz de enteros contiene un determinado int
• Ints.asList(int ...) crea una lista de enteros de una matriz int

Answer 6

Cuando se llama a

Arrays.asList(array) 

en su conjunto de primitivas, se obtiene una lista instancia que contiene un objeto: ¡una matriz de valores int! Primero debe convertir la matriz de primitivos en una matriz de objetos, como sugiere @Bozho en su respuesta.

Answer 7

Parece que su comprensión de Arrays.asList(T... a) es incorrecta. No sería la primera persona en suponer cómo funciona.

intentarlo con

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

Answer 8

Autoboxing simplemente no funciona de la manera que quiere que en este caso. El siguiente código puede ser un poco prolijo, pero cumple su cometido de convertir un array int a una lista:

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

Answer 9

Si sólo desea comprobar si la matriz contiene cierto elemento simplemente iterar sobre la matriz y buscar elementos. Esto tomará o (n/2). Todas las demás soluciones son menos efectivas. Cualquier método que copie la matriz para listar debe iterar sobre la matriz y, por lo tanto, esta operación solo requiere n asignaciones atómicas.

Answer 10

El siguiente código muestra true:

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

(Su versión falla, ya no es beeing Int objetos, pero int [] es un objeto para ello va a llamar asList (T ... a) con uno. elemento que contiene una Colección, ya que no es posible tener una Colección a)