Liste in Java in Array umwandeln

Question

Wie kann ich eine List zu einer Array in Java?

Prüfen Sie den unten stehenden Code:

ArrayList<Tienda> tiendas;
List<Tienda> tiendasList; 
tiendas = new ArrayList<Tienda>();

Resources res = this.getBaseContext().getResources();
XMLParser saxparser =  new XMLParser(marca,res);

tiendasList = saxparser.parse(marca,res);
tiendas = tiendasList.toArray();

this.adaptador = new adaptadorMarca(this, R.layout.filamarca, tiendas);
setListAdapter(this.adaptador);  

Ich muss das Array auffüllen tiendas mit den Werten von tiendasList .

Answer 1

Entweder:

Foo[] array = list.toArray(new Foo[0]);

o:

Foo[] array = new Foo[list.size()];
list.toArray(array); // fill the array

---

Beachten Sie, dass dies nur für Arrays von Referenztypen funktioniert. Für Arrays von primitiven Typen, verwenden Sie die traditionelle Weise:

List<Integer> list = ...;
int[] array = new int[list.size()];
for(int i = 0; i < list.size(); i++) array[i] = list.get(i);

---

Aktualisierung:

Es wird nun empfohlen, Folgendes zu verwenden list.toArray(new Foo[0]); pas list.toArray(new Foo[list.size()]); .

Von JetBrains Intellij Idea Inspektion:

Es gibt zwei Möglichkeiten, eine Sammlung in ein Array zu konvertieren: entweder mit ein vordefiniertes Array (wie c.toArray(new String[c.size()]) ) oder mit einem leeren Array (wie c.toArray(new String[0]) .

Unter älteren Java-Versionen wurde die Verwendung von Arrays mit vorgegebener Größe empfohlen, da der Reflection-Aufruf, der notwendig ist, um ein Array der richtigen Größe zu recht langsam war. Seit späten Updates von OpenJDK 6 wurde dieser Aufruf jedoch wurde dieser Aufruf integriert, wodurch die Leistung der leeren Array-Version gleich und manchmal sogar besser ist, als die Version mit vordefinierter Version. Auch die Übergabe eines Arrays mit vorgegebener Größe ist gefährlich für eine gleichzeitige oder synchronisierte Auflistung gefährlich, da ein Datenwettlauf zwischen den Größe y toArray Aufruf, der zu zusätzlichen Nullen führen kann am Ende des Arrays, wenn die Sammlung gleichzeitig verkleinert wurde während der Operation verkleinert wurde.

Diese Inspektion ermöglicht die Verfolgung der einheitlichen Stil zu folgen: entweder mit einem leeren Array (was in modernem Java empfohlen wird) Java empfohlen wird) oder die Verwendung eines Arrays mit vorgegebener Größe (was in älteren Java-Versionen oder nicht-HotSpot-basierten JVMs).

Answer 2

Eine Alternative in Java 8:

String[] strings = list.stream().toArray(String[]::new);

Seit Java 11:

String[] strings = list.toArray(String[]::new);

Answer 3

Ich denke, das ist der einfachste Weg:

Foo[] array = list.toArray(new Foo[0]);

Answer 4

Das Beste, was mir ohne Java 8 eingefallen ist, war:

public static <T> T[] toArray(List<T> list, Class<T> objectClass) {
    if (list == null) {
        return null;
    }

    T[] listAsArray = (T[]) Array.newInstance(objectClass, list.size());
    list.toArray(listAsArray);
    return listAsArray;
}

Wenn jemand einen besseren Weg kennt, dies zu tun, bitte mitteilen :)

Answer 5

Ich bin auf diesen Codeschnipsel gestoßen, der das Problem löst.

//Creating a sample ArrayList 
List<Long> list = new ArrayList<Long>();

//Adding some long type values
list.add(100l);
list.add(200l);
list.add(300l);

//Converting the ArrayList to a Long
Long[] array = (Long[]) list.toArray(new Long[list.size()]);

//Printing the results
System.out.println(array[0] + " " + array[1] + " " + array[2]);

Die Umwandlung funktioniert wie folgt:

1. Es wird ein neues Long-Array erstellt, das die Größe der ursprünglichen Liste hat
2. Es wandelt die ursprüngliche ArrayList in ein Array um, indem es das neu erstellte Array verwendet
3. Dieses Array wird in ein Long-Array (Long[]) umgewandelt, das ich passenderweise 'array' genannt habe