Wie kann ich List konvertieren zu int[] auf Java? [duplicate]

Ich bin Java-Neuling. Wie kann ich eine konvertieren List<Integer> zu int[] auf Java?

Ich bin verwirrt, weil List.toArray() gibt tatsächlich eine zurück Object[]die zu keinem von beiden gecastet werden kann Integer[] Noch int[].

Im Moment verwende ich dazu eine Schleife:

int[] toIntArray(List<Integer> list) {
  int[] ret = new int[list.size()];
  for(int i = 0; i < ret.length; i++)
    ret[i] = list.get(i);
  return ret;
}

Gibt es einen besseren Weg, dies zu tun?

_{Dies ist ähnlich wie die Frage
Wie kann ich int umwandeln?[] zu Ganzzahl[] auf Java?.}

Niemand hat bisher in Java 8 hinzugefügte Streams erwähnt, also hier ist es:

int[] example1 = list.stream().mapToInt(i->i).toArray();
// OR
int[] example2 = list.stream().mapToInt(Integer::intValue).toArray();

Denkprozess:

• Das Einfache Stream#toArray gibt ein zurück Object[] Array, also ist es nicht das, was wir wollen. Ebenfalls, Stream#toArray(IntFunction<A[]> generator) tut nicht, was wir wollen, weil der generische Typ A kann den primitiven Typ nicht darstellen int

• Es wäre also schön, einen Stream zu haben, der mit dem primitiven Typ umgehen könnte int anstelle der Verpackung Integerweil es toArray -Methode wird höchstwahrscheinlich auch eine zurückgeben int[] array (gibt etwas anderes zurück wie Object[] oder sogar verpackt Integer[] wäre hier unnatürlich). Und zum Glück hat Java 8 einen solchen Stream, der ist IntStream

• Jetzt müssen wir nur noch herausfinden, wie wir unsere umwandeln Stream<Integer> (was zurückgegeben wird von list.stream()) zu diesem glänzenden IntStream. Hier die Stream#mapToInt(ToIntFunction<? super T> mapper) Methode kommt zur Rettung. Alles, was wir tun müssen, ist, ihm ein Mapping von zu übergeben Integer zu int.

  Wir könnten so etwas gebrauchen Integer#intValue was ein zurückgibt int Wie nachfolgend dargestellt:

  mapToInt( (Integer i) -> i.intValue() )  
  

  (oder einige mögen es vorziehen: mapToInt(Integer::intValue).)

  Aber ähnlicher Code kann mit Unboxing generiert werden, da der Compiler weiß, dass das Ergebnis dieses Lambda vom Typ sein muss int (das verwendete Lambda in mapToInt ist eine Implementierung der ToIntFunction Schnittstelle, die als Körper eine Methode des Typs erwartet: int applyAsInt(T value) die voraussichtlich eine zurückgeben wird int).

  Wir können also einfach schreiben:

  mapToInt((Integer i)->i)
  

  Auch seit dem Integer eintippen (Integer i) kann vom Compiler abgeleitet werden, weil List<Integer>#stream() gibt a zurück Stream<Integer>wir können es auch überspringen, was uns übrig lässt

  mapToInt(i -> i)
  

Leider glaube ich da nicht wirklich ist eine bessere Möglichkeit, dies zu tun, da Java primitive Typen, Boxing, Arrays und Generika handhabt. Bestimmtes:

• List<T>.toArray funktioniert nicht, weil es keine Konvertierung von gibt Integer zu int
• Sie können nicht verwenden int als Typargument für Generika, so würde es verfügen über ein … sein int-spezifische Methode (oder eine, die Reflexion verwendet, um böse Tricks zu machen).

Ich glaube, es gibt Bibliotheken, die automatisch generierte Versionen dieser Art von Methode für alle primitiven Typen haben (dh es gibt eine Vorlage, die für jeden Typ kopiert wird). Es ist hässlich, aber ich fürchte, es ist so 🙁

Obwohl die Arrays Klasse herauskam, bevor Generika in Java ankamen, müsste sie immer noch all die schrecklichen Überladungen enthalten, wenn sie heute eingeführt würde (vorausgesetzt, Sie wollen primitive Arrays verwenden).

Zusätzlich zu Commons Lang können Sie dies mit tun Guave‘s Methode Ints.toArray(Collection<Integer> collection):

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

Dies erspart Ihnen die zwischenzeitliche Array-Konvertierung, die das Commons Lang-Äquivalent selbst erfordert.

Der einfachste Weg, dies zu tun, ist die Verwendung von Apache Commons Lang. Es hat eine praktische ArrayUtils-Klasse, die tun kann, was Sie wollen. Verwenden Sie die toPrimitive -Methode mit der Überladung für ein Array von IntegerS.

List<Integer> myList;
 ... assign and fill the list
int[] intArray = ArrayUtils.toPrimitive(myList.toArray(new Integer[myList.size()]));

So erfindet man das Rad nicht neu. Commons Lang hat sehr viele nützliche Dinge, die Java weggelassen hat. Oben habe ich mich entschieden, eine Integer-Liste der richtigen Größe zu erstellen. Sie können auch ein statisches Integer-Array der Länge 0 verwenden und Java ein Array der richtigen Größe zuweisen lassen:

static final Integer[] NO_INTS = new Integer[0];
   ....
int[] intArray2 = ArrayUtils.toPrimitive(myList.toArray(NO_INTS));

Java 8 hat uns eine einfache Möglichkeit gegeben, dies über Streams zu tun …

Verwendung der Sammlungen stream() -Funktion und dann auf ints abbilden, erhalten Sie einen IntStream. Mit dem IntStream wir können toArray() aufrufen, was uns gibt int []

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

zu int []

zu IntStream

int[] toIntArray(List<Integer> list)  {
    int[] ret = new int[list.size()];
    int i = 0;
    for (Integer e : list)  
        ret[i++] = e;
    return ret;
}

Leichte Änderung an Ihrem Code, um eine teure Listenindizierung zu vermeiden (da eine Liste nicht unbedingt eine ArrayList ist, sondern eine verkettete Liste sein könnte, für die wahlfreier Zugriff teuer ist)

Hier ist Java 8 einzeiliger Code dafür

public int[] toIntArray(List<Integer> intList){
       return intList.stream().mapToInt(Integer::intValue).toArray();
}