Sto cercando di convertire un ArrayList contenente oggetti Integer in int primitivo [] con il seguente pezzo di codice, ma sta generando un errore di tempo di compilazione. È possibile convertire in Java?

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

Puoi convertire, ma non credo che ci sia qualcosa incorporato per farlo 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;
}

(Nota che questo genererà una NullPointerException se uno integerso più elementi al suo interno lo sono null.)

MODIFICA: Come da commenti, potresti voler utilizzare l'iteratore di elenchi per evitare costi negativi con elenchi come 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 stai usando java-8 c'è anche un altro modo per farlo.

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

Quello che fa è:

• ottenere un Stream<Integer>dalla lista
• ottenere un IntStreammappando ogni elemento su se stesso (funzione di identità), unboxing il intvalore trattenuto da ciascun Integeroggetto (fatto automaticamente da Java 5)
• ottenere l'array di intchiamandotoArray

È inoltre possibile chiamare esplicitamente intValuetramite un riferimento al metodo, ad esempio:

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

Vale anche la pena ricordare che potresti ottenere un NullPointerExceptionse hai qualche nullriferimento nell'elenco. Ciò potrebbe essere facilmente evitato aggiungendo una condizione di filtro alla pipeline del flusso in questo modo:

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

Esempio:

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

Google Guava fornisce un modo pulito per farlo chiamando Ints.toArray.

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

Apache Commons ha una classe ArrayUtils, che ha un metodo toPrimitive () che fa esattamente questo.

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

Tuttavia, come ha dimostrato Jon, è abbastanza facile farlo da soli invece di usare librerie esterne.

Credo che iterare usando l'iteratore dell'elenco sia un'idea migliore, poiché list.get(i)può avere scarse prestazioni a seconda dell'implementazione dell'elenco:

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

usare Dollar dovrebbe essere abbastanza semplice:

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

Sto pianificando di migliorare il DSL per rimuovere la toArray()chiamata intermedia

Questo funziona bene per me :)

Trovato su 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));
    }
}

Mi sorprende che incoraggiamo metodi personalizzati una tantum ogni volta che una libreria perfettamente funzionante e ben usata come Apache Commons ha già risolto il problema. Sebbene la soluzione sia banale se non assurda, è irresponsabile incoraggiare un simile comportamento a causa della manutenzione e dell'accessibilità a lungo termine.

Basta andare con Apache Commons

Se si utilizzano le raccolte Eclipse , è possibile utilizzare il collectInt()metodo per passare da un contenitore di oggetti a un contenitore 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 riesci a convertire il tuo ArrayListin a FastList, puoi eliminare l'adattatore.

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

Nota: sono un committer per le raccolte 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));

Produzione:

Matrice di ints primitivi: [7, 9, 13]

Le stesse opere per un array di longo double, ma non per array boolean, char, byte, shorto float. Se hai un elenco davvero enorme, c'è anche un parallelSetAllmetodo che potresti usare invece.

Per me questo è abbastanza buono ed elgante che non vorrei avere una libreria esterna né usare i flussi per esso.

Link alla documentazione: Arrays.setAll(int[], IntUnaryOperator)

Puoi semplicemente copiarlo su un array:

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

Non troppo lussuoso; ma, ehi, funziona ...

Una soluzione a una riga molto semplice è:

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

Questo segmento di codice funziona per me, prova questo:

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

Vale la pena ricordare che ArrayList dovrebbe essere dichiarato così:

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

accesso arrcome al solito int[].