Risposte:
List<String> list = ..;
String[] array = list.toArray(new String[0]);
Per esempio:
List<String> list = new ArrayList<String>();
//add some stuff
list.add("android");
list.add("apple");
String[] stringArray = list.toArray(new String[0]);
Il toArray()
metodo senza passare alcun argomento restituisce Object[]
. Quindi devi passare un array come argomento, che verrà riempito con i dati dall'elenco e restituito. Puoi anche passare un array vuoto, ma puoi anche passare un array con le dimensioni desiderate.
Aggiornamento importante : originariamente il codice sopra utilizzato new String[list.size()]
. Tuttavia, questo post sul blog rivela che a causa delle ottimizzazioni di JVM, l'utilizzo new String[0]
è migliore ora.
Class
dell'oggetto reale , che sembra essere del tutto impossibile derivare dal tipo generico. La ragione di ciò, come ho detto, è che l'intera costruzione è falsa; è tutto memorizzato come Oggetto internamente.
Un'alternativa in Java 8:
String[] strings = list.stream().toArray(String[]::new);
Java 11+:
String[] strings = list.toArray(String[]::new);
toArray
su un Stream
oggetto. Questo errore di compilazione può verificarsi se si riduce lo stream utilizzando a Collectors
e quindi si tenta di applicare toArray
.
È possibile utilizzare il toArray()
metodo per List
:
ArrayList<String> list = new ArrayList<String>();
list.add("apple");
list.add("banana");
String[] array = list.toArray(new String[list.size()]);
Oppure puoi aggiungere manualmente gli elementi a un array:
ArrayList<String> list = new ArrayList<String>();
list.add("apple");
list.add("banana");
String[] array = new String[list.size()];
for (int i = 0; i < list.size(); i++) {
array[i] = list.get(i);
}
Spero che sia di aiuto!
ArrayList<String> arrayList = new ArrayList<String>();
Object[] objectList = arrayList.toArray();
String[] stringArray = Arrays.copyOf(objectList,objectList.length,String[].class);
Utilizzando copyOf, ArrayList per le matrici potrebbe anche essere eseguito.
A partire da Java-11, in alternativa è possibile utilizzare l'API Collection.toArray(IntFunction<T[]> generator)
per ottenere lo stesso risultato di:
List<String> list = List.of("x","y","z");
String[] arrayBeforeJDK11 = list.toArray(new String[0]);
String[] arrayAfterJDK11 = list.toArray(String[]::new); // similar to Stream.toArray
In Java 8:
String[] strings = list.parallelStream().toArray(String[]::new);
parallelStream()
invece semplicemente stream()
?
Soluzione generica per convertire qualsiasi List<Type>
a String []
:
public static <T> String[] listToArray(List<T> list) {
String [] array = new String[list.size()];
for (int i = 0; i < array.length; i++)
array[i] = list.get(i).toString();
return array;
}
Nota È necessario il override toString()
metodo.
class Car {
private String name;
public Car(String name) {
this.name = name;
}
public String toString() {
return name;
}
}
final List<Car> carList = new ArrayList<Car>();
carList.add(new Car("BMW"))
carList.add(new Car("Mercedes"))
carList.add(new Car("Skoda"))
final String[] carArray = listToArray(carList);
List <String> list = ...
String[] array = new String[list.size()];
int i=0;
for(String s: list){
array[i++] = s;
}
nel caso in cui si desideri una manipolazione aggiuntiva dei dati, per la quale l'utente desidera una funzione, questo approccio non è perfetto (in quanto richiede il passaggio della classe dell'elemento come secondo parametro), ma funziona:
import java.util.ArrayList; import java.lang.reflect.Array;
public class Test {
public static void main(String[] args) {
ArrayList<Integer> al = new ArrayList<>();
al.add(1);
al.add(2);
Integer[] arr = convert(al, Integer.class);
for (int i=0; i<arr.length; i++)
System.out.println(arr[i]);
}
public static <T> T[] convert(ArrayList<T> al, Class clazz) {
return (T[]) al.toArray((T[])Array.newInstance(clazz, al.size()));
}
}
Se l'applicazione utilizza già la libreria Apache Commons, è possibile modificare leggermente la risposta accettata per non creare un nuovo array vuoto ogni volta:
List<String> list = ..;
String[] array = list.toArray(ArrayUtils.EMPTY_STRING_ARRAY);
// or if using static import
String[] array = list.toArray(EMPTY_STRING_ARRAY);
Ci sono alcune altre matrici vuote preallocate di diversi tipi in ArrayUtils
.
Inoltre, possiamo ingannare JVM per creare un array vuoto per noi in questo modo:
String[] array = list.toArray(ArrayUtils.toArray());
// or if using static import
String[] array = list.toArray(toArray());
Ma non c'è davvero alcun vantaggio in questo modo, solo una questione di gusti, IMO.
Puoi usare Iterator<String>
per iterare gli elementi di ArrayList<String>
:
ArrayList<String> list = new ArrayList<>();
String[] array = new String[list.size()];
int i = 0;
for (Iterator<String> iterator = list.iterator(); iterator.hasNext(); i++) {
array[i] = iterator.next();
}
Ora puoi recuperare elementi da String[]
dall'uso di qualsiasi loop.
.toString()
dove non sarebbe necessario un cast esplicito, 3. non aumenti nemmeno i
, e 4. while
sarebbe meglio sostituito da a for
. Codice suggerito:ArrayList<String> stringList = ... ; String[] stringArray = new String[stringList.size()]; int i = 0; for(Iterator<String> it = stringList.iterator(); it.hasNext(); i++) { stringArray[i] = it.next(); }
In Java 11, possiamo usare il Collection.toArray(generator)
metodo. Il codice seguente creerà un nuovo array di stringhe:
List<String> list = List.of("one", "two", "three");
String[] array = list.toArray(String[]::new)
List<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
String [] strArry= list.stream().toArray(size -> new String[size]);
Per i commenti, ho aggiunto un paragrafo per spiegare come funziona la conversione. Innanzitutto, Elenco viene convertito in un flusso String. Quindi utilizza Stream.toArray per convertire gli elementi nel flusso in un array. Nell'ultima istruzione sopra "size -> new String [size]" è in realtà una funzione IntFunction che alloca un array String con le dimensioni del flusso String. L'affermazione è identica a
IntFunction<String []> allocateFunc = size -> {
return new String[size];
};
String [] strArry= list.stream().toArray(allocateFunc);
È possibile convertire l'elenco in array String utilizzando questo metodo:
Object[] stringlist=list.toArray();
L'esempio completo:
ArrayList<String> list=new ArrayList<>();
list.add("Abc");
list.add("xyz");
Object[] stringlist=list.toArray();
for(int i = 0; i < stringlist.length ; i++)
{
Log.wtf("list data:",(String)stringlist[i]);
}
private String[] prepareDeliveryArray(List<DeliveryServiceModel> deliveryServices) {
String[] delivery = new String[deliveryServices.size()];
for (int i = 0; i < deliveryServices.size(); i++) {
delivery[i] = deliveryServices.get(i).getName();
}
return delivery;
}
toArray(T[])
e una sintassi simile aStream.toArray
.