Conversione di 'ArrayList <String> in' String [] 'in Java


Risposte:


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

Per esempio:

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

Il toArray()metodo senza passare alcun argomento restituisce Object[]. Quindi devi passare un array come argomento, che verrà riempito con i dati dall'elenco e restituito. Puoi anche passare un array vuoto, ma puoi anche passare un array con le dimensioni desiderate.

Aggiornamento importante : originariamente il codice sopra utilizzato new String[list.size()]. Tuttavia, questo post sul blog rivela che a causa delle ottimizzazioni di JVM, l'utilizzo new String[0]è migliore ora.


16
La dimensione dell'argomento fa qualche differenza?
Thorbjørn Ravn Andersen,

37
salva un'ulteriore installazione di array
Bozho,

59
Si scopre che fornire un array di lunghezza zero, persino crearlo e buttarlo via, è in media più veloce rispetto all'allocazione di un array della giusta dimensione. Per benchmark e spiegazioni vedi qui: shipilev.net/blog/2016/arrays-wisdom-ancients
Stuart Marks

2
(Mi dispiace. Domanda retorica. La risposta è, ovviamente, perché Java non fa veri generici; per lo più li
finge

3
@lyuboslavkanev Il problema è che avere il tipo generico in Java non è sufficiente per creare effettivamente oggetti basati su quel tipo; nemmeno un array (il che è ridicolo, perché dovrebbe funzionare per qualsiasi tipo). Tutto ciò che può essere fatto con esso, per quanto posso vedere, è il casting. In effetti, per creare anche oggetti del tipo, è necessario disporre Classdell'oggetto reale , che sembra essere del tutto impossibile derivare dal tipo generico. La ragione di ciò, come ho detto, è che l'intera costruzione è falsa; è tutto memorizzato come Oggetto internamente.
Nyerguds,

170

Un'alternativa in Java 8:

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

Java 11+:

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

25
O qualche beneficio?
James Watkins,

1
Preferirei quella sintassi, ma IntelliJ mostra un errore del compilatore con quello, si lamenta "T [] non è un'interfaccia funzionale".
Glen Mazza,

3
@GlenMazza è possibile utilizzare solo toArraysu un Streamoggetto. Questo errore di compilazione può verificarsi se si riduce lo stream utilizzando a Collectorse quindi si tenta di applicare toArray.
Udara Bentota,

39

È possibile utilizzare il toArray()metodo per List:

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

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

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

Oppure puoi aggiungere manualmente gli elementi a un array:

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

Spero che sia di aiuto!


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

Utilizzando copyOf, ArrayList per le matrici potrebbe anche essere eseguito.


4
Suggerisci camelcase così "objectList = ..." e "stringArray". Inoltre, è Arrays.copyOf ... maiuscola O.
Jason Weden,

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

25

A partire da Java-11, in alternativa è possibile utilizzare l'API Collection.toArray(IntFunction<T[]> generator)per ottenere lo stesso risultato di:

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

In Java 8:

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

12
Questo è già contenuto in questa risposta . Forse aggiungilo come modifica a quella risposta anziché come completamente nuova.
Fiume,

11
Perché parallelStream()invece semplicemente stream()?
Yoory N.

7

In Java 8, può essere fatto usando

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

6

Soluzione generica per convertire qualsiasi 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 È necessario il override toString()metodo.

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
Funziona, ma non è super efficiente e duplica la funzionalità nella risposta accettata con un codice aggiuntivo.
Alan Delimon,

5

nel caso in cui si desideri una manipolazione aggiuntiva dei dati, per la quale l'utente desidera una funzione, questo approccio non è perfetto (in quanto richiede il passaggio della classe dell'elemento come secondo parametro), ma funziona:

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

Se l'applicazione utilizza già la libreria Apache Commons, è possibile modificare leggermente la risposta accettata per non creare un nuovo array vuoto ogni volta:

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

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

Ci sono alcune altre matrici vuote preallocate di diversi tipi in ArrayUtils .

Inoltre, possiamo ingannare JVM per creare un array vuoto per noi in questo modo:

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

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

Ma non c'è davvero alcun vantaggio in questo modo, solo una questione di gusti, IMO.


5

Puoi usare Iterator<String> per iterare gli elementi di 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();
}

Ora puoi recuperare elementi da String[] dall'uso di qualsiasi loop.


Ho effettuato il downvoting perché: 1. nessun uso di generici che ti costringono a 2. usare .toString()dove non sarebbe necessario un cast esplicito, 3. non aumenti nemmeno i, e 4. whilesarebbe meglio sostituito da a for. Codice suggerito: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,

Okay, l'ho capito adesso. Grazie.
Vatsal Chavda,

Bene, idealmente, dovresti modificare il tuo codice per includere quei commenti (cioè ... se pensi che siano buoni per la tua risposta!). Non prenderò in considerazione la rimozione del mio downvote mentre il codice rimane invariato.
Olivier Grégoire,

Sono nuovo qui, quindi non so ancora come funzionano le cose qui. Tuttavia, apprezzo il tuo aiuto amico.
Vatsal Chavda,

È molto meglio! Ho modificato solo un po ', ma hai appena sperimentato come funziona: fornire una risposta, migliorarli, ottenere gli allori;)
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]);

Per i commenti, ho aggiunto un paragrafo per spiegare come funziona la conversione. Innanzitutto, Elenco viene convertito in un flusso String. Quindi utilizza Stream.toArray per convertire gli elementi nel flusso in un array. Nell'ultima istruzione sopra "size -> new String [size]" è in realtà una funzione IntFunction che alloca un array String con le dimensioni del flusso String. L'affermazione è identica a

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

4
Quale valore aggiunge questa risposta? Sembra semplicemente ripetere altre risposte senza spiegare perché risponde alla domanda.
Richard,

2

È possibile convertire l'elenco in array String utilizzando questo metodo:

 Object[] stringlist=list.toArray();

L'esempio 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;
}
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.