example - list object to string java

Convertir ''ArrayList<String> a'' String[] ''en Java

Question

¿Cómo puedo convertir un objeto ArrayList<String> en una matriz String[] en Java?

Answer 1

Al usar el método toArray() de ArrayList, puede obtener 0bject[] . Convierta ese Object[] a String[] Aquí el código de ejemplo:

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

Answer 2

Con JDK / 11, uno puede usar alternativamente un API Collection.toArray(IntFunction<T[]> generator) recién introducido para lograr lo mismo 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

Answer 3

En Java 11, podemos usar el método Collection.toArray(generator) . El siguiente código creará una nueva matriz de cadenas:

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

de java.base''s java.util.Collection.toArray() .

Answer 4

En Java 8, se puede hacer usando

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

Answer 5

En Java 8:

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

Answer 6

En caso de que se desee una manipulación adicional de los datos, para la cual el usuario desea una función, este enfoque no es perfecto (ya que requiere pasar la clase del elemento como segundo parámetro), pero funciona:

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

Answer 7

Esto es suficiente:

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

Answer 8

Puede usar Iterator<String> para iterar los elementos 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();
}

Ahora puedes recuperar elementos de String[] usando cualquier Loop.

Answer 9

Puedes convertir la lista en una matriz de cadenas usando este método:

 Object[] stringlist=list.toArray();

El ejemplo completo:

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

Answer 10

Puedes usar el método toArray() para List :

ArrayList<String> list = new ArrayList<String>();
list.add("apple");
list.add("banana");
String[] array = list.toArray(new String[list.size()]);

O puede agregar manualmente los elementos a una matriz:

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

¡Espero que esto ayude!

Answer 11

Si su aplicación ya está utilizando la biblioteca de Apache Commons, puede modificar ligeramente la respuesta aceptada para no crear una nueva matriz vacía cada vez:

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

Hay algunos más arreglos vacíos preasignados de diferentes tipos en ArrayUtils .

También podemos engañar a JVM para que cree una matriz vacía de esta manera:

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

Pero realmente no hay ventaja de esta manera, solo es cuestión de gustos, OMI.

Answer 12

Solución genérica para convertir cualquier List<Type> a 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;
}

Nota Debe override toString() método override toString() .

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

Answer 13

Una alternativa en Java 8:

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

Answer 14

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

Usando copyOf, ArrayList para arreglos también se puede hacer.

Answer 15

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

Answer 16

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

Por ejemplo:

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

El método toArray() sin pasar ningún argumento devuelve Object[] . Por lo tanto, debe pasar una matriz como argumento, que se rellenará con los datos de la lista y se devolverá. También puede pasar una matriz vacía, pero también puede pasar una matriz con el tamaño deseado.

Actualización importante : Originalmente, el código anterior usaba una new String[list.size()] . Sin embargo, esta entrada de blog revela que debido a las optimizaciones de JVM, es mejor usar la new String[0] ahora.

Answer 17

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