java - postgres - ¿Cómo convertir una matriz int[] a una lista?

postgresql json example

Question

Esperaba que este código se mostrara true :

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

Answer 1

Autoboxing simplemente no funciona de la manera que usted quiere en este caso. El siguiente código puede ser un poco detallado, pero hace el trabajo de convertir una matriz int en una lista:

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

Answer 2

Cuando usted llama

Arrays.asList(array)

en su matriz de primitivas, obtiene una instancia de lista 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 3

El Arrays.asList(array) dará como resultado una lista singleton de un int[] .

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

Answer 4

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

Una matriz de primitivos es un Object (vea también esta pregunta ), pero no un Object[] , por lo que el compilador cree que está usando la versión de varargs y genera una matriz de Objetos alrededor de su matriz int. Puedes 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 tu código. También obviamente devuelve falso.

El compilador traduce las llamadas de varargs en llamadas con una sola matriz, por lo que llamar a un método de varargs que espere los parámetros T ... con los parámetros T t1, T t2, T t3 es equivalente a llamarlo con la new T[]{t1, t2, t3} pero el caso especial aquí es que los varargs con primitivas se desactivarán automáticamente antes de que se cree la matriz si el método necesita una matriz de objetos. Así que el compilador piensa que la matriz int se pasa como un solo objeto y crea una matriz de un solo elemento 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 lo 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));

Aquí hay algunas formas buenas y malas de llamar a 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:

• Tutorial de Java > Clases y objetos > Pasar información a un método o un constructor > Varargs
• Arrays.asList(T ...)

Pero para resolver realmente su problema de una manera simple:

Hay algunas soluciones de biblioteca en Apache Commons / Lang (ver la respuesta de Bozho ) y en Google Guava :

• Ints.contains(int[], int) verifica si una matriz de ints contiene un int dado
• Ints.asList(int ...) crea una lista de enteros a partir de una matriz int

Answer 5

El siguiente código se muestra verdadero:

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

(La versión falla, ya que Int no está siendo objetos, pero Int [] es un objeto. Por lo tanto, llamará asList (T ... a) con un elemento dentro de una Colección, ya que no es posible tener una Colección a).

Answer 6

Esta

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

devuelve true

Answer 7

No creo que exista un método que puedas usar. Pruébalo así

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

Answer 8

Parece que tu comprensión de Arrays.asList(T... a) es incorrecta. No serías la primera persona en hacer una suposición de cómo funciona.

Pruébalo con

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

Answer 9

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

Answer 10

Arrays.asList(ArrayUtils.toObjectArray(array))

( ArrayUtils es de commons-lang )

Pero si solo quieres llamar contains no hay necesidad de eso. Simplemente use Arrays.binarySearch(..) (ordene la matriz primero)