Hoe kan ik een List converteren naar een Array in Java?
Controleer de onderstaande 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);
Ik moet de array tiendas vullen met de waarden van tiendasList.
Antwoord 1, autoriteit 100%
Ofwel:
Foo[] array = list.toArray(new Foo[0]);
of:
Foo[] array = new Foo[list.size()];
list.toArray(array); // fill the array
Merk op dat dit alleen werkt voor arrays van referentietypes. Gebruik voor arrays van primitieve typen de traditionele manier:
List<Integer> list = ...;
int[] array = new int[list.size()];
for(int i = 0; i < list.size(); i++) array[i] = list.get(i);
Bijwerken:
Het wordt nu aanbevolen om list.toArray(new Foo[0]); te gebruiken, niet list.toArray(new Foo[list.size()]);.
Van JetBrains Intellij Idee-inspectie:
Er zijn twee stijlen om een verzameling naar een array te converteren: ofwel met
een vooraf ingestelde array (zoals c.toArray(new String[c.size()])) of
met een lege array (zoals c.toArray(new String[0]).In
oudere Java-versies die een voorgerangschikte array gebruiken, werden aanbevolen, omdat de
reflectie-oproep die nodig is om een array van de juiste grootte te maken
was vrij traag. Maar sinds late updates van OpenJDK 6 deze oproep:
was geïntrinseerd, waardoor de prestaties van de lege array-versie
hetzelfde en soms zelfs beter, vergeleken met de pre-sized
versie. Ook het doorgeven van een pre-sized array is gevaarlijk voor een gelijktijdige of
gesynchroniseerde verzameling als een datarace is mogelijk tussen de
size en toArray aanroepen, wat kan resulteren in extra nulls
aan het einde van de array, als de verzameling tegelijkertijd is verkleind
tijdens de operatie.Deze inspectie maakt het mogelijk om de
uniforme stijl: ofwel met een lege array (die wordt aanbevolen in
moderne Java) of met behulp van een vooraf ingestelde array (wat misschien sneller is in
oudere Java-versies of niet-HotSpot-gebaseerde JVM’s).
Antwoord 2, autoriteit 19%
Een alternatief in Java 8:
String[] strings = list.stream().toArray(String[]::new);
Sinds Java 11:
String[] strings = list.toArray(String[]::new);
Antwoord 3, autoriteit 4%
Ik denk dat dit de eenvoudigste manier is:
Foo[] array = list.toArray(new Foo[0]);
Antwoord 4
Ik kwam dit codefragment tegen dat het oplost.
//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]);
De conversie werkt als volgt:
- Het creëert een nieuwe lange array, met de grootte van de originele lijst
- Het converteert de originele ArrayList naar een array met de nieuw aangemaakte
- Het werpt die array in een lange array (Long[]), die ik toepasselijk ‘array’ heb genoemd
Antwoord 5
Het beste wat ik bedacht zonder Java 8 was:
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;
}
Als iemand een betere manier heeft om dit te doen, deel het dan alsjeblieft 🙂
Antwoord 6
Dit is werken. Soort van.
public static Object[] toArray(List<?> a) {
Object[] arr = new Object[a.size()];
for (int i = 0; i < a.size(); i++)
arr[i] = a.get(i);
return arr;
}
Dan de hoofdmethode.
public static void main(String[] args) {
List<String> list = new ArrayList<String>() {{
add("hello");
add("world");
}};
Object[] arr = toArray(list);
System.out.println(arr[0]);
}
Antwoord 7
Voor ArrayList werken de volgende:
ArrayList<Foo> list = new ArrayList<Foo>();
//... add values
Foo[] resultArray = new Foo[list.size()];
resultArray = list.toArray(resultArray);
Antwoord 8
Voorbeeld overgenomen van deze pagina: http: //www.java-examples.com/copy-all-elements-java-arraylist-object-array-example
import java.util.ArrayList;
public class CopyElementsOfArrayListToArrayExample {
public static void main(String[] args) {
//create an ArrayList object
ArrayList arrayList = new ArrayList();
//Add elements to ArrayList
arrayList.add("1");
arrayList.add("2");
arrayList.add("3");
arrayList.add("4");
arrayList.add("5");
/*
To copy all elements of java ArrayList object into array use
Object[] toArray() method.
*/
Object[] objArray = arrayList.toArray();
//display contents of Object array
System.out.println("ArrayList elements are copied into an Array.
Now Array Contains..");
for(int index=0; index < objArray.length ; index++)
System.out.println(objArray[index]);
}
}
/*
Output would be
ArrayList elements are copied into an Array. Now Array Contains..
1
2
3
4
5
Antwoord 9
Je kunt toArray() api als volgt gebruiken,
ArrayList<String> stringList = new ArrayList<String>();
stringList.add("ListItem1");
stringList.add("ListItem2");
String[] stringArray = new String[stringList.size()];
stringArray = stringList.toArray(stringList);
Waarden uit de array zijn,
for(String value : stringList)
{
System.out.println(value);
}
Antwoord 10
Dit (antwoord van Ondrej):
Foo[] array = list.toArray(new Foo[0]);
Is het meest voorkomende idioom dat ik zie. Degenen die suggereren dat u de werkelijke lijstgrootte gebruikt in plaats van “0”, begrijpen niet wat hier gebeurt. De toArray-aanroep geeft niet om de grootte of inhoud van de gegeven array – het heeft alleen het type nodig. Het zou beter zijn geweest als er een echt type voor nodig was, in welk geval “Foo.class” een stuk duidelijker zou zijn geweest. Ja, dit idioom genereert een dummy-object, maar het opnemen van de lijstgrootte betekent alleen dat u een groter dummy-object genereert. Nogmaals, het object wordt op geen enkele manier gebruikt; het is alleen het type dat nodig is.
Antwoord 11
Probeer dit:
List list = new ArrayList();
list.add("Apple");
list.add("Banana");
Object[] ol = list.toArray();