Estou tentando converter um ArrayList contendo objetos Inteiros para int primitivo] com o seguinte pedaço de código, mas está lançando um erro de tempo de compilação. É possível converter em Java?

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

Você pode converter, mas acho que não há nada incorporado para fazer isso automaticamente:

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;
}

(Observe que isso lançará uma NullPointerException se um integersou qualquer elemento dele for null.)

EDIT: conforme os comentários, convém usar o iterador da lista para evitar custos desagradáveis ​​com 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;
}

Se você estiver usando java-8 também há outra maneira de fazer isso.

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

O que ele faz é:

• recebendo um Stream<Integer>da lista
• obtendo um IntStreammapeando cada elemento para si mesmo (função de identidade), descompactando o intvalor retido por cada Integerobjeto (feito automaticamente desde o Java 5)
• obtendo a matriz intchamandotoArray

Você também pode chamar explicitamente intValueatravés de uma referência de método, ou seja:

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

Também vale a pena mencionar que você pode obter um NullPointerExceptionse tiver alguma nullreferência na lista. Isso pode ser facilmente evitado adicionando uma condição de filtragem ao pipeline de fluxo como este:

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

Exemplo:

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 Guava

O Google Guava fornece uma maneira elegante de fazer isso ligando Ints.toArray.

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

O Apache Commons possui uma classe ArrayUtils, que possui um método toPrimitive () que faz exatamente isso.

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]));

No entanto, como Jon mostrou, é muito fácil fazer isso sozinho, em vez de usar bibliotecas externas.

Acredito que iterar usando o iterador da Lista é uma idéia melhor, pois list.get(i)pode ter um desempenho ruim, dependendo da implementação da 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 deve ser bastante simples:

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

Estou planejando melhorar o DSL para remover a toArray()chamada intermediária

Isso funciona bem para mim :)

Encontrado em 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));
    }
}

Surpreende-me que incentivemos métodos personalizados únicos sempre que uma biblioteca perfeitamente boa e bem usada, como o Apache Commons, já resolveu o problema. Embora a solução seja trivial, se não absurda, é irresponsável incentivar esse comportamento devido à manutenção e acessibilidade a longo prazo.

Basta ir com o Apache Commons

Se você estiver usando Coleções Eclipse , poderá usar o collectInt()método para alternar de um contêiner de objeto para um contêiner 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());

Se você pode converter seu ArrayListem um FastList, pode se livrar do adaptador.

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

Nota: Sou responsável por coleções do 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));

Resultado:

Matriz de ints primitivos: [7, 9, 13]

O mesmo vale para uma matriz de longou double, mas não para matrizes de boolean, char, byte, shortou float. Se você tem uma lista realmente grande, há até um parallelSetAllmétodo que você pode usar.

Para mim, isso é bom e elegante o suficiente para que eu não queira obter uma biblioteca externa nem usar fluxos para ela.

Link da documentação: Arrays.setAll(int[], IntUnaryOperator)

Você pode simplesmente copiá-lo para uma matriz:

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

Não é muito chique; mas, ei, funciona ...

Uma solução simples de uma linha é:

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

Este segmento de código está funcionando para mim, tente o seguinte:

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

Vale mencionar que ArrayList deve ser declarado assim:

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()]);

acesso arrcomo normal int[].