web-dev-qa-db-fra.com

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

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

javaarraysstringarraylistcollections
937
Alex
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 méthode toArray() sans passer d'argument renvoie Object[]. Vous devez donc passer un tableau en tant qu'argument, qui sera rempli avec les données de la liste et renvoyé. Vous pouvez également transmettre un tableau vide, mais vous pouvez également transmettre un tableau de la taille souhaitée.

Mise à jour importante : À l'origine, le code ci-dessus utilisait new String[list.size()]. Cependant, this blogpost révèle que, grâce aux optimisations JVM, utiliser new String[0] est préférable.

1693
Bozho

Une alternative dans Java 8:

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

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

J'espère que cela t'aides!

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

En utilisant copyOf, ArrayList dans les tableaux peut également être utilisé.

28
Rajesh Vemula

À partir de la JDK/11, on peut également utiliser l’API Collection.toArray(IntFunction<T[]> generator) identique à:

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
18
Naman

Dans Java 8:

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

Generics solution pour convertir n'importe quel List<Type> en 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() method.

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);
5
Khaled Lela

au 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 en tant que second paramètre), mais fonctionne comme suit:

importer Java.util.ArrayList; importer 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()));
  }
}
4
Roberto Attias

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

Vous pouvez maintenant récupérer des éléments de _String[]_ en utilisant n’importe quelle boucle.

4
Vatsal Chavda
List <String> list = ...
String[] array = new String[list.size()];
int i=0;
for(String s: list){
  array[i++] = s;
}
4
HZhang

Si votre application utilise déjà Apache Commons lib, 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 y a encore quelques tableaux vides préalloués de types différents dans ArrayUtils.

Nous pouvons aussi tromper la JVM pour qu'elle crée un tableau vide:

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.

4
Yoory N.

Dans Java 8, vous pouvez utiliser

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

Vous pouvez convertir la liste 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]);
    }
3
Panchal Nilkanth

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

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

from Java.util.Collection.toArray() de Java.base.

3
Rafal Borowiec
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;
}
2
Denis Fedak
    List<String> list = new ArrayList<>();
    list.add("a");
    list.add("b");
    list.add("c");
    String [] strArry= list.stream().toArray(size -> new String[size]);

Tout d'abord, la liste est convertie en un flux de chaîne. Ensuite, il utilise Stream.toArray pour renvoyer un tableau contenant les éléments du flux String. "taille -> new String [taille]" est une fonction IntFunction qui alloue un tableau String avec la taille du flux String. Il peut être réorganisé comme

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

Conversion d'une ArrayList en String []:

//Creating an ArrayList of String object and populating it
ArrayList<String> list = new ArrayList<String>();
list.add("Item 1");
list.add("Item 2");
list.add("Item 3");
list.add("Item 4");

//Creating a String array with the same size as that of the ArrayList
String[] stringArray = new String[list.size()];

//Now converting the ArrayList to a String array
stringArray = list.toArray(stringArray);
0
CoderSam