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

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

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 toArray()Methode ohne Übergabe eines Arguments wird zurückgegeben Object[]. 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 genannte Code verwendet new String[list.size()]. Dieser Blogpost zeigt jedoch, dass die Verwendung aufgrund von JVM-Optimierungen new String[0]jetzt besser ist.

Eine Alternative in Java 8:

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

Java 11+:

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

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

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!

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 ausgeführt werden.

Ausgehend von Java-11 kann alternativ die API verwendet werden Collection.toArray(IntFunction<T[]> generator), 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

In Java 8:

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

In Java 8 kann dies mit erfolgen

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

Generics Lösung verdeckte jede List<Type>an 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;
}

Hinweis Sie müssen override toString()Methode.

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

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

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

Es gibt einige weitere vorab zugewiesene leere Arrays verschiedener Typen in ArrayUtils.

Wir können JVM auch 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.

Sie können verwenden Iterator<String>, um die Elemente von 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();
}

Jetzt können Sie Elemente aus String[]jeder Schleife abrufen .

In Java 11 können wir die Collection.toArray(generator)Methode verwenden. Der folgende Code erstellt ein neues Array von Zeichenfolgen:

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

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

Per Kommentar habe ich einen Absatz hinzugefügt, um zu erklären, wie die Konvertierung funktioniert. Zunächst wird List in einen String-Stream konvertiert. Anschließend wird Stream.toArray verwendet, um die Elemente im Stream in ein Array zu konvertieren. In der letzten obigen Anweisung ist "size -> new String [size]" eine IntFunction-Funktion, die ein String-Array mit der Größe des String-Streams zuweist. Die Aussage ist identisch mit

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

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

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