Come convertire un ArrayList contenente gli Integer nell’array primitivo int?

Sto cercando di convertire un object ArrayList contenente oggetti interi in primitive int [] con il seguente pezzo di codice, ma sta generando un errore in fase di compilazione. È ansible convertire in Java?

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

Puoi convertire, ma non credo che ci sia qualcosa di integrato per farlo automaticamente:

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

(Si noti che questo genererà una NullPointerException se i integers o qualsiasi elemento al suo interno sono null ).

EDIT: Come per i commenti, potresti voler usare l'elenco iteratore per evitare spiacevoli costi con liste come LinkedList :

 public static int[] convertIntegers(List integers) { int[] ret = new int[integers.size()]; Iterator 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 uno Stream dall’elenco
  • ottenendo un IntStream mappando ogni elemento a se stesso (funzione id quadro), annullando la chiusura del valore int trattenuto da ciascun object Integer (eseguito automaticamente da Java 5)
  • ottenere la matrice di toArray chiamando toArray

È anche ansible chiamare esplicitamente intValue tramite un riferimento al metodo, ovvero:

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

Vale anche la pena ricordare che potresti ottenere una NullPointerException se hai un riferimento null nell’elenco. Questo potrebbe essere facilmente evitato aggiungendo una condizione di filtraggio alla pipeline dello stream come questa:

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

Esempio:

 List 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 ha una class ArrayUtils, che ha un metodo toPrimitive () che fa esattamente questo.

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

Tuttavia, come ha mostrato Jon, è piuttosto semplice farlo da solo invece di usare le librerie esterne.

Google Guava

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

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

Credo che iterare utilizzando l’iteratore di List sia un’idea migliore, dato che list.get(i) può avere prestazioni scadenti a seconda dell’implementazione List:

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

l’utilizzo di Dollar dovrebbe essere abbastanza semplice:

 List 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() intermedia toArray()

Se si utilizzano raccolte Eclipse , è ansible utilizzare il metodo collectInt() per passare da un contenitore di oggetti a un contenitore int primitivo.

 List 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 è ansible convertire ArrayList in FastList , è ansible 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 di Eclipse.

Mi sconcerta che incoraggiamo metodi personalizzati una tantum ogni volta che una biblioteca perfettamente valida e ben utilizzata come Apache Commons ha già risolto il problema. Anche se la soluzione è banale, se non assurda, è irresponsabile incoraggiare un tale comportamento a causa della manutenzione e dell’accessibilità a lungo termine.

Basta andare con Apache Commons

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 elaborato; ma, ehi, funziona ...

Questo segmento di codice funziona per me, prova questo

 Integer[] arr = x.toArray(new Integer[x.size()]); 
  List list = new ArrayList(); 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 arr come normale int[] .