¿Cómo convertir int en List en Java?

¿Cómo convierto int[] en List en Java?

Por supuesto, estoy interesado en cualquier otra respuesta que hacerlo en un bucle, elemento por elemento. Pero si no hay otra respuesta, seleccionaré esa como la mejor para mostrar el hecho de que esta funcionalidad no es parte de Java.

No hay atajos para convertir de int[] a List ya que Arrays.asList no se ocupa del boxeo y solo creará una List que no es lo que desea. Tienes que hacer un método de utilidad.

 int[] ints = {1, 2, 3}; List intList = new ArrayList(); for (int i : ints) { intList.add(i); } 

en Java 8 puedes hacer esto

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

También de las bibliotecas de guayaba … com.google.common.primitives.Ints:

 List Ints.asList(int...) 

Arrays.asList no funcionará como esperan algunas de las otras respuestas.

Este código no creará una lista de 10 enteros. Imprimirá 1 , no 10 :

 int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; List lst = Arrays.asList(arr); System.out.println(lst.size()); 

Esto creará una lista de enteros:

 List lst = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); 

Si ya tiene la matriz de entradas, no hay una forma rápida de convertir, está mejor con el ciclo.

Por otro lado, si su matriz tiene objetos, no primitivos, Arrays.asList funcionará:

 String str[] = { "Homer", "Marge", "Bart", "Lisa", "Maggie" }; List lst = Arrays.asList(str); 

Agregaré otra respuesta con un método diferente; sin bucle, pero una clase anónima que utilizará las funciones de autoboxing:

 public List asList(final int[] is) { return new AbstractList() { public Integer get(int i) { return is[i]; } public int size() { return is.length; } }; } 

La pieza más pequeña de código sería:

 public List myWork(int[] array) { return Arrays.asList(ArrayUtils.toObject(array)); } 

donde ArrayUtils proviene de commons-lang 🙂

En Java 8 con transmisión:

 int[] ints = {1, 2, 3}; List list = new ArrayList(); Collections.addAll(list, Arrays.stream(ints).boxed().toArray(Integer[]::new)); 

o con coleccionistas

 List list = Arrays.stream(ints).boxed().collect(Collectors.toList()); 

En Java 8:

 int[] arr = {1,2,3}; IntStream.of(arr).boxed().collect(Collectors.toList()); 

También vale la pena consultar este informe de error , que se cerró con el motivo “No es un defecto” y el siguiente texto:

“Autoboxing de matrices enteras no se especifica el comportamiento, por una buena razón. Puede ser prohibitivamente costoso para grandes matrices”.

probar a esta clase:

 class PrimitiveWrapper extends AbstractList { private final T[] data; private PrimitiveWrapper(T[] data) { this.data = data; // you can clone this array for preventing aliasing } public static  List ofIntegers(int... data) { return new PrimitiveWrapper(toBoxedArray(Integer.class, data)); } public static  List ofCharacters(char... data) { return new PrimitiveWrapper(toBoxedArray(Character.class, data)); } public static  List ofDoubles(double... data) { return new PrimitiveWrapper(toBoxedArray(Double.class, data)); } // ditto for byte, float, boolean, long private static  T[] toBoxedArray(Class boxClass, Object components) { final int length = Array.getLength(components); Object res = Array.newInstance(boxClass, length); for (int i = 0; i < length; i++) { Array.set(res, i, Array.get(components, i)); } return (T[]) res; } @Override public T get(int index) { return data[index]; } @Override public int size() { return data.length; } } 

caso de prueba:

 List ints = PrimitiveWrapper.ofIntegers(10, 20); List doubles = PrimitiveWrapper.ofDoubles(10, 20); // etc 

La mejor foto:

 ** * Integer modifiable fix length list of an int array or many int's. * * @author Daniel De Leon. */ public class IntegerListWrap extends AbstractList { int[] data; public IntegerListWrap(int... data) { this.data = data; } @Override public Integer get(int index) { return data[index]; } @Override public Integer set(int index, Integer element) { int r = data[index]; data[index] = element; return r; } @Override public int size() { return data.length; } } 
  • Soporte get y set
  • Sin duplicación de datos de memoria.
  • Sin perder el tiempo en loops.

Ejemplos:

 int[] intArray = new int[]{1, 2, 3}; List integerListWrap = new IntegerListWrap(intArray); List integerListWrap1 = new IntegerListWrap(1, 2, 3); 

Si está abierto a usar una biblioteca de terceros, esto funcionará en las Colecciones de Eclipse :

 int[] a = {1, 2, 3}; List integers = IntLists.mutable.with(a).collect(i -> i); Assert.assertEquals(Lists.mutable.with(1, 2, 3), integers); 

Nota: soy un committer para las colecciones de Eclipse .

Aquí hay una solución:

 int[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; Integer[] iArray = Arrays.stream(array).boxed().toArray(Integer[]::new); System.out.println(Arrays.toString(iArray)); List list = new ArrayList<>(); Collections.addAll(list, iArray); System.out.println(list); 

Salida:

 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 

Aquí hay una forma genérica de convertir array a ArrayList

  ArrayList toArrayList(Object o, Class type){ ArrayList objects = new ArrayList<>(); for (int i = 0; i < Array.getLength(o); i++) { //noinspection unchecked objects.add((T) Array.get(o, i)); } return objects; } 

Uso

 ArrayList list = toArrayList(new int[]{1,2,3}, Integer.class); 
  /* Integer[] to List */ Integer[] intArr = { 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 }; List arrList = new ArrayList<>(); arrList.addAll(Arrays.asList(intArr)); System.out.println(arrList); /* Integer[] to Collection */ Integer[] intArr = { 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 }; Collection c = Arrays.asList(intArr); 

¿Qué tal esto?

int[] a = {1,2,3}; Integer[] b = ArrayUtils.toObject(a); List c = Arrays.asList(b);