Si está utilizando 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
• obteniendo un IntStream asignando cada elemento a sí mismo (función de identidad), deshaciendo el valor int retenido por cada objeto Integer (hecho automáticamente desde Java 5)
• obteniendo el array de int llamando a toArray

También puede llamar explícitamente a intValue a través de una referencia de método, i. e:

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

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

                       //.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]

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 Jon mostró, es bastante fácil hacer esto por ti mismo en lugar de usar bibliotecas externas.

Google Guayaba

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

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

Creo que iterar usando el iterador de la Lista es una mejor idea, ya que list.get(i) puede tener un rendimiento pobre 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 llamada intermedia toArray()

Si está utilizando Colecciones de Eclipse, puede usar el método collectInt() 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 ArrayList a un 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.

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

Simplemente vaya con Apache Commons

Simplemente puede copiarlo en un array:

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

No es demasiado elegante; pero, bueno, funciona...

Este segmento de código está funcionando para mí, pruebe esto

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

   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 arr como normal int[].