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


Respuestas:


1792
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 toArray()método sin pasar ningún argumento devuelve Object[]. Por lo tanto, debe pasar una matriz como argumento, que se completará 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 se utilizó el código anterior new String[list.size()]. Sin embargo, esta publicación de blog revela que debido a las optimizaciones de JVM, el uso new String[0]es mejor ahora.


16
¿El tamaño del argumento hace alguna diferencia?
Thorbjørn Ravn Andersen

37
ahorra una nueva instigación de matriz
Bozho

59
Resulta que proporcionar una matriz de longitud cero, incluso crearla y tirarla, es en promedio más rápido que asignar una matriz del tamaño correcto. Para ver los puntos de referencia y la explicación, consulte aquí: shipilev.net/blog/2016/arrays-wisdom-ancients
Stuart Marks

2
(Lo siento. Pregunta retórica. La respuesta es, por supuesto, porque Java no hace genéricos reales; en su mayoría solo los falsifica al lanzar Object)
Nyerguds

3
@lyuboslavkanev El problema es que tener el tipo genérico en Java no es suficiente para crear objetos basados ​​en ese tipo; ni siquiera una matriz (lo cual es ridículo, porque eso debería funcionar para cualquier tipo). Todo lo que se puede hacer con él, hasta donde puedo ver, es el casting. De hecho, incluso para crear objetos del tipo, debe tener el Classobjeto real , que parece ser completamente imposible de derivar del tipo genérico. La razón de esto, como dije, es que toda la construcción es falsa; todo se almacena internamente como Objeto.
Nyerguds

170

Una alternativa en Java 8:

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

Java 11+:

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

25
¿O algún beneficio?
James Watkins el

1
Preferiría esa sintaxis, pero IntelliJ muestra un error de compilación con eso, se queja "T [] no es una interfaz funcional".
Glen Mazza

3
@GlenMazza solo se puede usar toArrayen un Streamobjeto. Este error de compilación puede ocurrir si reduce la secuencia usando a Collectorsy luego intenta aplicar toArray.
Udara Bentota

39

Puedes usar el toArray()método 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!


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

Usando copyOf, ArrayList a las matrices también se puede hacer.


44
Sugerir camelcase para "objectList = ..." y "stringArray". Además, es Arrays.copyOf ... capital O.
Jason Weden

1
list.toArray () usa internamente Arrays.copyOf ()
David

25

A partir de Java-11, uno puede usar alternativamente la API Collection.toArray(IntFunction<T[]> generator)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

10

En Java 8:

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

12
Esto realmente ya está contenido en esta respuesta . Quizás lo agregue como una edición a esa respuesta en lugar de como una respuesta completamente nueva.
Río

11
¿Por qué en parallelStream()lugar de simplemente stream()?
Yoory N.

7

En Java 8, se puede hacer usando

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

6

Solución genérica para convertir cualquiera 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.

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

13
Esto funciona, pero no es súper eficiente, y duplica la funcionalidad en la respuesta aceptada con código adicional.
Alan Delimon

5

en caso de que se desee una manipulación adicional de los datos, para lo 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()));
  }
}

5

Si su aplicación ya está usando la biblioteca 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 algunas más matrices vacías preasignadas de diferentes tipos en ArrayUtils.

También podemos engañar a JVM para crear una matriz vacía para nosotros 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, en mi opinión.


5

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 puede recuperar elementos del String[]uso de cualquier bucle.


Voté en contra porque: 1. no usas genéricos que te obligan a usar 2. usar .toString()donde no se necesitaría un lanzamiento explícito, 3. ni siquiera incrementas i, y 4. whilesería mejor reemplazarlo por a for. Código sugerido:ArrayList<String> stringList = ... ; String[] stringArray = new String[stringList.size()]; int i = 0; for(Iterator<String> it = stringList.iterator(); it.hasNext(); i++) { stringArray[i] = it.next(); }
Olivier Grégoire

Está bien, lo tengo ahora. Gracias.
Vatsal Chavda

Bueno, idealmente, debe editar su código para incluir esos comentarios (es decir ... ¡si cree que son buenos para su respuesta!). No consideraré eliminar mi voto negativo mientras el código permanezca sin cambios.
Olivier Grégoire

Soy nuevo aquí, así que aún no sé cómo funcionan las cosas aquí. Aunque, agradezco su ayuda compañero.
Vatsal Chavda

¡Esto es mucho mejor! He editado solo un poco, pero acabas de experimentar cómo funciona: dar respuesta, mejorarlos, obtener los laureles;)
Olivier Grégoire


4
    List<String> list = new ArrayList<>();
    list.add("a");
    list.add("b");
    list.add("c");
    String [] strArry= list.stream().toArray(size -> new String[size]);

Por comentarios, he agregado un párrafo para explicar cómo funciona la conversión. Primero, la lista se convierte en una secuencia de cadena. Luego usa Stream.toArray para convertir los elementos en la secuencia a una matriz. En la última declaración anterior, "size -> new String [size]" es en realidad una función IntFunction que asigna una matriz String con el tamaño de la secuencia String. La declaración es idéntica a

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

44
¿Qué valor agrega esta respuesta? Parece que solo repite otras respuestas sin explicar por qué responde la pregunta.
Richard

2

Puede convertir la lista a la matriz de cadenas utilizando 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]);
    }

1
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;
}
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.