Convertir 'ArrayList <String> a' String [] 'en Java

¿Cómo puedo convertir un ArrayList<String>objeto en una String[]matriz en Java?

List<String> list = ..;
String[] array = list.toArray(new String[0]);

Por ejemplo:

List<String> list = new ArrayList<String>();
//add some stuff
list.add("android");
list.add("apple");
String[] stringArray = list.toArray(new String[0]);

El toArray()método sin pasar ningún argumento devuelve Object[]. Por lo tanto, debe pasar una matriz como argumento, que se completará con los datos de la lista y se devolverá. También puede pasar una matriz vacía, pero también puede pasar una matriz con el tamaño deseado.

Actualización importante : originalmente se utilizó el código anterior new String[list.size()]. Sin embargo, esta publicación de blog revela que debido a las optimizaciones de JVM, el uso new String[0]es mejor ahora.

Una alternativa en Java 8:

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

Java 11+:

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

Puedes usar el toArray()método para List:

ArrayList<String> list = new ArrayList<String>();

list.add("apple");
list.add("banana");

String[] array = list.toArray(new String[list.size()]);

O puede agregar manualmente los elementos a una matriz:

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

¡Espero que esto ayude!

ArrayList<String> arrayList = new ArrayList<String>();
Object[] objectList = arrayList.toArray();
String[] stringArray =  Arrays.copyOf(objectList,objectList.length,String[].class);

Usando copyOf, ArrayList a las matrices también se puede hacer.

A partir de Java-11, uno puede usar alternativamente la API Collection.toArray(IntFunction<T[]> generator)para lograr lo mismo que:

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

En Java 8:

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

En Java 8, se puede hacer usando

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

Solución genérica para convertir cualquiera 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 Debe override toString()método.

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

en caso de que se desee una manipulación adicional de los datos, para lo cual el usuario desea una función, este enfoque no es perfecto (ya que requiere pasar la clase del elemento como segundo parámetro), pero funciona:

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

Si su aplicación ya está usando la biblioteca Apache Commons, puede modificar ligeramente la respuesta aceptada para no crear una nueva matriz vacía cada vez:

List<String> list = ..;
String[] array = list.toArray(ArrayUtils.EMPTY_STRING_ARRAY);

// or if using static import
String[] array = list.toArray(EMPTY_STRING_ARRAY);

Hay algunas más matrices vacías preasignadas de diferentes tipos en ArrayUtils.

También podemos engañar a JVM para crear una matriz vacía para nosotros de esta manera:

String[] array = list.toArray(ArrayUtils.toArray());

// or if using static import
String[] array = list.toArray(toArray());

Pero realmente no hay ventaja de esta manera, solo es cuestión de gustos, en mi opinión.

Puede usar Iterator<String>para iterar los elementos de 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();
}

Ahora puede recuperar elementos del String[]uso de cualquier bucle.

En Java 11, podemos usar el Collection.toArray(generator)método. El siguiente código creará una nueva matriz de cadenas:

List<String> list = List.of("one", "two", "three");
String[] array = list.toArray(String[]::new)

de 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]);

Por comentarios, he agregado un párrafo para explicar cómo funciona la conversión. Primero, la lista se convierte en una secuencia de cadena. Luego usa Stream.toArray para convertir los elementos en la secuencia a una matriz. En la última declaración anterior, "size -> new String [size]" es en realidad una función IntFunction que asigna una matriz String con el tamaño de la secuencia String. La declaración es idéntica a

IntFunction<String []> allocateFunc = size -> { 
return new String[size];
};   
String [] strArry= list.stream().toArray(allocateFunc);

Puede convertir la lista a la matriz de cadenas utilizando este método:

 Object[] stringlist=list.toArray();

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