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

une alternative en Java 8:

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

vous pouvez utiliser la méthode toArray() 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);
}

Espérons que cette aide!

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

utilisant copyOf, ArrayList to arrays pourrait être fait aussi.

En Java 8:

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

avec JDK / 11, on peut alternativement utiliser une API nouvellement introduite Collection.toArray(IntFunction<T[]> generator) to achieve the same as:

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

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

importer java.util.ArrayList; importer java.lang.refléter.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()));
  }
}

Génériques la solution pour convertir tous 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;
}

Note Vous devez override toString() la 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;
}

si votre application utilise déjà Apache Commons lib, vous pouvez modifier légèrement 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 y a quelques autres matrices vides préallouées de différents types dans ArrayUtils .

aussi nous pouvons tromper JVM pour créer en empty array 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, IMO.

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

Maintenant vous pouvez récupérer des éléments de String[] en utilisant n'importe quelle boucle.

vous pouvez convertir la liste en tableau de chaînes de caractères 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;
}

en Java 8, Il peut être fait en utilisant

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

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

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

voir: https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Collection.html#toArray(java.util.function.IntFunction)

en utilisant toArray() méthode D'ArrayList vous pouvez obtenir 0bject[] . Object[] à String[] Voici le code de l'échantillon:

ArrayList<String> arr_List=new ArrayList<String>();
Object[] str_Arr=arr_List.toArray();

C'est assez:

int[] d = new int[list.size()];

for (int i = 0; i < list.size(); i++) {
    d[i] = list.get(i);
}