Estoy tratando de convertir una ArrayList que contiene objetos Integer en primitivo int [] con el siguiente fragmento de código, pero arroja un error de tiempo de compilación. ¿Es posible convertir en Java?

List<Integer> x =  new ArrayList<Integer>();
int[] n = (int[])x.toArray(int[x.size()]);

Puede convertir, pero no creo que haya nada incorporado para hacerlo automáticamente:

public static int[] convertIntegers(List<Integer> integers)
{
    int[] ret = new int[integers.size()];
    for (int i=0; i < ret.length; i++)
    {
        ret[i] = integers.get(i).intValue();
    }
    return ret;
}

(Tenga en cuenta que esto arrojará una NullPointerException si alguno integerso cualquier elemento dentro de él es null).

EDITAR: según los comentarios, es posible que desee utilizar el iterador de lista para evitar costos desagradables con listas como LinkedList:

public static int[] convertIntegers(List<Integer> integers)
{
    int[] ret = new int[integers.size()];
    Iterator<Integer> iterator = integers.iterator();
    for (int i = 0; i < ret.length; i++)
    {
        ret[i] = iterator.next().intValue();
    }
    return ret;
}

Si estas usando java-8 También hay otra forma de hacer esto.

int[] arr = list.stream().mapToInt(i -> i).toArray();

Lo que hace es:

• obteniendo un Stream<Integer>de la lista
• obtener un IntStreammapeo de cada elemento a sí mismo (función de identidad), desempaquetar el intvalor retenido por cada Integerobjeto (hecho automáticamente desde Java 5)
• obtener la matriz de intllamandotoArray

También puede llamar explícitamente a intValuetravés de una referencia de método, es decir:

int[] arr = list.stream().mapToInt(Integer::intValue).toArray();

También vale la pena mencionar que podría obtener un NullPointerExceptionsi tiene alguna nullreferencia en la lista. Esto podría evitarse fácilmente agregando una condición de filtrado a la tubería de flujo de esta manera:

                       //.filter(Objects::nonNull) also works
int[] arr = list.stream().filter(i -> i != null).mapToInt(i -> i).toArray();

Ejemplo:

List<Integer> list = Arrays.asList(1, 2, 3, 4);
int[] arr = list.stream().mapToInt(i -> i).toArray(); //[1, 2, 3, 4]

list.set(1, null); //[1, null, 3, 4]
arr = list.stream().filter(i -> i != null).mapToInt(i -> i).toArray(); //[1, 3, 4]

Google guayaba

Google Guava proporciona una forma ordenada de hacer esto llamando Ints.toArray.

List<Integer> list = ...;
int[] values = Ints.toArray(list);

Apache Commons tiene una clase ArrayUtils, que tiene un método toPrimitive () que hace exactamente esto.

import org.apache.commons.lang.ArrayUtils;
...
    List<Integer> list = new ArrayList<Integer>();
    list.add(new Integer(1));
    list.add(new Integer(2));
    int[] intArray = ArrayUtils.toPrimitive(list.toArray(new Integer[0]));

Sin embargo, como demostró Jon, es bastante fácil hacerlo usted mismo en lugar de usar bibliotecas externas.

Creo que iterar usando el iterador de la Lista es una mejor idea, ya que list.get(i)puede tener un bajo rendimiento dependiendo de la implementación de la Lista:

private int[] buildIntArray(List<Integer> integers) {
    int[] ints = new int[integers.size()];
    int i = 0;
    for (Integer n : integers) {
        ints[i++] = n;
    }
    return ints;
}

usar Dollar debería ser bastante simple:

List<Integer> list = $(5).toList(); // the list 0, 1, 2, 3, 4  
int[] array = $($(list).toArray()).toIntArray();

Estoy planeando mejorar el DSL para eliminar la toArray()llamada intermedia

Esto funciona bien para mí :)

Encontrado en https://www.techiedelight.com/convert-list-integer-array-int/

import java.util.Arrays;
import java.util.List;

class ListUtil
{
    // Program to convert list of integer to array of int in Java
    public static void main(String args[])
    {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);

        int[] primitive = list.stream()
                            .mapToInt(Integer::intValue)
                            .toArray();

        System.out.println(Arrays.toString(primitive));
    }
}

Me desconcierta que fomentemos métodos personalizados únicos cuando una biblioteca perfectamente buena y bien utilizada como Apache Commons ya haya resuelto el problema. Aunque la solución es trivial si no es absurda, es irresponsable fomentar ese comportamiento debido al mantenimiento y la accesibilidad a largo plazo.

Solo ve con Apache Commons

Si está utilizando Eclipse Collections , puede utilizar el collectInt()método para cambiar de un contenedor de objetos a un contenedor int primitivo.

List<Integer> integers = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
MutableIntList intList =
  ListAdapter.adapt(integers).collectInt(i -> i);
Assert.assertArrayEquals(new int[]{1, 2, 3, 4, 5}, intList.toArray());

Si puede convertir su ArrayLista FastList, puede deshacerse del adaptador.

Assert.assertArrayEquals(
  new int[]{1, 2, 3, 4, 5},
  Lists.mutable.with(1, 2, 3, 4, 5)
    .collectInt(i -> i).toArray());

Nota: Soy un committer para las colecciones de Eclipse.

Java 8:

int[] intArr = Arrays.stream(integerList).mapToInt(i->i).toArray();

Arrays.setAll ()

    List<Integer> x = new ArrayList<>(Arrays.asList(7, 9, 13));
    int[] n = new int[x.size()];
    Arrays.setAll(n, x::get);

    System.out.println("Array of primitive ints: " + Arrays.toString(n));

Salida:

Matriz de entradas primitivas: [7, 9, 13]

Lo mismo funciona para una gran variedad de longo double, pero no para las matrices de boolean, char, byte, shorto float. Si tienes una lista realmente enorme, incluso hay un parallelSetAllmétodo que puedes usar en su lugar.

Para mí, esto es lo suficientemente bueno y elegante como para que no quiera obtener una biblioteca externa ni usar secuencias para ella.

Enlace de documentación: Arrays.setAll(int[], IntUnaryOperator)

Simplemente puede copiarlo a una matriz:

int[] arr = new int[list.size()];
for(int i = 0; i < list.size(); i++) {
    arr[i] = list.get(i);
}

No muy elegante; pero, oye, funciona ...

Una solución muy simple de una línea es:

Integer[] i = arrlist.stream().toArray(Integer[]::new);

Este segmento de código funciona para mí, prueba esto:

Integer[] arr = x.toArray(new Integer[x.size()]);

Vale la pena mencionar que ArrayList debería declararse así:

ArrayList<Integer> list = new ArrayList<>();

   List<Integer> list = new ArrayList<Integer>();

    list.add(1);
    list.add(2);

    int[] result = null;
    StringBuffer strBuffer = new StringBuffer();
    for (Object o : list) {
        strBuffer.append(o);
        result = new int[] { Integer.parseInt(strBuffer.toString()) };
        for (Integer i : result) {
            System.out.println(i);
        }
        strBuffer.delete(0, strBuffer.length());
    }

Integer[] arr = (Integer[]) x.toArray(new Integer[x.size()]);

Acceso arrcomo normal int[].