Conversione di 'ArrayList <String> in' String [] 'in Java

Come potrei convertire un ArrayList<String>oggetto in un String[]array in Java?

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.

Un'alternativa in Java 8:

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

Java 11+:

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

È 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);

In Java 8, può essere fatto usando

String[] arrayFromList = fromlist.stream().toArray(String[]::new);

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.

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)

da java.base's java.util.Collection.toArray() .

    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;
}