web-dev-qa-db-ger.com

Konvertieren von 'ArrayList <String> in' String [] 'in Java

Wie kann ich ein ArrayList<String> -Objekt in ein String[] -Array in Java konvertieren?

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

Zum Beispiel:

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

Die Methode toArray() ohne Übergabe eines Arguments gibt Object[] zurück. Sie müssen also ein Array als Argument übergeben, das mit den Daten aus der Liste gefüllt und zurückgegeben wird. Sie können auch ein leeres Array übergeben, aber Sie können auch ein Array mit der gewünschten Größe übergeben.

Wichtiges Update : Ursprünglich wurde der oben angegebene Code new String[list.size()] verwendet. Allerdings zeigt dieser Blogpost , dass aufgrund von JVM-Optimierungen die Verwendung von new String[0] jetzt besser ist.

1693
Bozho

Eine Alternative in Java 8:

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

Sie können die Methode toArray() für List verwenden:

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

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

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

Oder Sie können die Elemente manuell zu einem Array hinzufügen:

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

Hoffe das hilft!

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

Mit copyOf kann ArrayList auch für Arrays verwendet werden.

28
Rajesh Vemula

Ab JDK/11 kann alternativ die API Collection.toArray(IntFunction<T[]> generator) verwendet werden, um Folgendes zu erreichen:

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

In Java 8:

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

Generics Lösung, um List<Type> in String [] umzuwandeln:

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

Hinweis Sie müssen die override toString() -Methode verwenden.

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

falls eine zusätzliche Manipulation der Daten gewünscht wird, für die der Benutzer eine Funktion wünscht, ist dieser Ansatz nicht perfekt (da die Klasse des Elements als zweiter Parameter übergeben werden muss), sondern funktioniert:

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

Sie können Iterator<String> verwenden, um die Elemente des _ArrayList<String>_ zu durchlaufen:

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

Jetzt können Sie Elemente aus _String[]_ mit einer beliebigen Schleife abrufen.

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

Wenn Ihre Anwendung bereits Apache Commons lib verwendet, können Sie die akzeptierte Antwort leicht ändern, um nicht jedes Mal ein neues leeres Array zu erstellen:

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

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

In ArrayUtils gibt es einige weitere vorab zugewiesene leere Arrays verschiedener Typen.

Außerdem können wir JVM auf diese Weise dazu bringen, ein leeres Array für uns zu erstellen:

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

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

Aber auf diese Weise gibt es wirklich keinen Vorteil, nur Geschmackssache, IMO.

4
Yoory N.

In Java 8 kann dies mit ausgeführt werden

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

Mit dieser Methode können Sie List in String-Array konvertieren:

 Object[] stringlist=list.toArray();

Das vollständige Beispiel:

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

In Java 11 können wir die Collection.toArray(generator) -Methode verwenden. Mit dem folgenden Code wird ein neues Array von Zeichenfolgen erstellt:

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

from Java.bases Java.util.Collection.toArray() .

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

Zunächst wird List in einen String-Stream konvertiert. Anschließend wird Stream.toArray verwendet, um ein Array zurückzugeben, das die Elemente des String-Streams enthält. "size -> new String [size]" ist eine IntFunction-Funktion, die ein String-Array mit der Größe des String-Streams zuweist. Es kann neu angeordnet werden als

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

Konvertieren einer ArrayList in einen 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