Conversion de 'ArrayList <String> en' String [] 'en Java

Comment convertir un ArrayList<String>objet en String[]tableau en Java?

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

Par exemple:

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

La toArray()méthode sans passer aucun argument renvoie Object[]. Vous devez donc passer un tableau comme argument, qui sera rempli avec les données de la liste et renvoyé. Vous pouvez également passer un tableau vide, mais vous pouvez également passer un tableau avec la taille souhaitée.

Mise à jour importante : à l'origine le code ci-dessus utilisé new String[list.size()]. Cependant, ce blog révèle qu'en raison des optimisations JVM, l'utilisation new String[0]est meilleure maintenant.

Une alternative en Java 8:

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

Java 11+:

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

Vous pouvez utiliser la toArray()méthode pour List:

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

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

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

Ou vous pouvez ajouter manuellement les éléments à un tableau:

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

J'espère que cela t'aides!

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

En utilisant copyOf, ArrayList aux tableaux peut également être fait.

À partir de Java-11, on peut également utiliser l'API Collection.toArray(IntFunction<T[]> generator)pour obtenir la même chose 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, cela peut être fait en utilisant

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

Génériques solution secrète tout List<Type>à 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;
}

Remarque Vous devez override toString()méthode.

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

dans le cas où une manipulation supplémentaire des données est souhaitée, pour laquelle l'utilisateur souhaite une fonction, cette approche n'est pas parfaite (car elle nécessite de passer la classe de l'élément comme deuxième paramètre), mais fonctionne:

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 votre application utilise déjà la bibliothèque Apache Commons, vous pouvez légèrement modifier la réponse acceptée pour ne pas créer un nouveau tableau vide à chaque fois:

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

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

Il existe quelques autres tableaux vides préalloués de différents types dans ArrayUtils .

Nous pouvons aussi tromper JVM pour créer un tableau vide pour nous de cette façon:

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

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

Mais il n'y a vraiment aucun avantage de cette façon, juste une question de goût, OMI.

Vous pouvez utiliser Iterator<String>pour itérer les éléments 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();
}

Vous pouvez désormais retirer des éléments de String[]toute boucle.

En Java 11, nous pouvons utiliser la Collection.toArray(generator)méthode. Le code suivant créera un nouveau tableau de chaînes:

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

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

Par commentaires, j'ai ajouté un paragraphe pour expliquer comment fonctionne la conversion. Tout d'abord, List est converti en un flux String. Ensuite, il utilise Stream.toArray pour convertir les éléments du flux en tableau. Dans la dernière instruction ci-dessus, "size -> new String [size]" est en fait une fonction IntFunction qui alloue un tableau String avec la taille du flux String. La déclaration est identique à

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

Vous pouvez convertir List en tableau String en utilisant cette méthode:

 Object[] stringlist=list.toArray();

L'exemple complet:

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