¿Cómo convertir int[] en la Lista<Integer> en Java?

arrays collections

Question

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

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

Answer 1

Corrientes

En Java 8 puedes hacer esto.

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

Answer 2

¿Qué pasa con esto?

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

Answer 3

Agregaré otra respuesta con un método diferente; ningún bucle, sino una clase anónima que utilizará las características de autoboxing:

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

Answer 4

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

<T> ArrayList<T> toArrayList(Object o, Class<T> type){
    ArrayList<T> 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<Integer> list = toArrayList(new int[]{1,2,3}, Integer.class);

Answer 5

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<Integer> 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]

Answer 6

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

Este código no creará una lista de 10 enteros. Se 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<Integer> 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 bucle.

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

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

Answer 7

Dale una oportunidad a esta clase:

class PrimitiveWrapper<T> extends AbstractList<T> {

    private final T[] data;

    private PrimitiveWrapper(T[] data) {
        this.data = data; // you can clone this array for preventing aliasing
    }

    public static <T> List<T> ofIntegers(int... data) {
        return new PrimitiveWrapper(toBoxedArray(Integer.class, data));
    }

    public static <T> List<T> ofCharacters(char... data) {
        return new PrimitiveWrapper(toBoxedArray(Character.class, data));
    }

    public static <T> List<T> ofDoubles(double... data) {
        return new PrimitiveWrapper(toBoxedArray(Double.class, data));
    }  

    // ditto for byte, float, boolean, long

    private static <T> T[] toBoxedArray(Class<T> 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<Integer> ints = PrimitiveWrapper.ofIntegers(10, 20);
List<Double> doubles = PrimitiveWrapper.ofDoubles(10, 20);
// etc

Answer 8

El código más pequeño sería:

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

donde ArrayUtils viene de commons-lang :)

Answer 9

El mejor tiro:

**
 * Integer modifiable fix length list of an int array or many int''s.
 *
 * @author Daniel De Leon.
 */
public class IntegerListWrap extends AbstractList<Integer> {

    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 obtener y configurar.
• No hay duplicación de datos de memoria.
• No se pierde tiempo en bucles.

Ejemplos:

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

Answer 10

En Java 8 con stream:

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

o con coleccionistas

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

Answer 11

En Java 8:

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

Answer 12

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

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

Answer 13

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

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

Nota: Soy un comendador de Eclipse Collections .

Answer 14

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

List<Integer> Ints.asList(int...)

Answer 15

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 arreglos completos no es un comportamiento específico, por una buena razón. Puede ser prohibitivamente costoso para arreglos grandes".

Answer 16

   /* Integer[] to List<Integer> */



        Integer[] intArr = { 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 };
        List<Integer> arrList = new ArrayList<>();
        arrList.addAll(Arrays.asList(intArr));
        System.out.println(arrList);


/* Integer[] to Collection<Integer> */


    Integer[] intArr = { 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 };
    Collection<Integer> c = Arrays.asList(intArr);