Come convertire array di oggetti in array di stringhe in Java

Uso il seguente codice per convertire un array di oggetti in un array di stringhe:

Object Object_Array[]=new Object[100];
// ... get values in the Object_Array

String String_Array[]=new String[Object_Array.length];

for (int i=0;i<String_Array.length;i++) String_Array[i]=Object_Array[i].toString();

Ma mi chiedo se c'è un altro modo per farlo, qualcosa del tipo:

String_Array=(String[])Object_Array;

Ma ciò causerebbe un errore di runtime: Exception in thread "AWT-EventQueue-0" java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.String;

Qual è il modo corretto di farlo?

Un'altra alternativa a System.arraycopy:

String[] stringArray = Arrays.copyOf(objectArray, objectArray.length, String[].class);

In Java 8:

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

Per convertire una matrice di altri tipi:

String[] strings = Arrays.stream(obj).map(Object::toString).
                   toArray(String[]::new);

System.arraycopy è probabilmente il modo più efficiente, ma per l'estetica preferirei:

 Arrays.asList(Object_Array).toArray(new String[Object_Array.length]);

Vedo che sono state fornite alcune soluzioni, ma non alcuna causa, quindi lo spiegherò in dettaglio poiché ritengo sia importante sapere che cosa hai fatto di sbagliato piuttosto che ottenere "qualcosa" che funzioni dalle risposte fornite.

Innanzitutto, vediamo cosa ha da dire Oracle

 * <p>The returned array will be "safe" in that no references to it are
 * maintained by this list.  (In other words, this method must
 * allocate a new array even if this list is backed by an array).
 * The caller is thus free to modify the returned array.

Potrebbe non sembrare importante, ma come vedrai è ... Quindi, cosa fallisce la seguente riga? Tutti gli oggetti nell'elenco sono String ma non li converte, perché?

List<String> tList = new ArrayList<String>();
tList.add("4");
tList.add("5");
String tArray[] = (String[]) tList.toArray();   

Probabilmente, molti di voi penserebbero che questo codice stia facendo lo stesso, ma non lo è.

Object tSObjectArray[] = new String[2];
String tStringArray[] = (String[]) tSObjectArray;

Quando in realtà il codice scritto sta facendo qualcosa del genere. Lo dice javadoc! Istituirà un nuovo array, quello che sarà degli Oggetti !!!

Object tSObjectArray[] = new Object[2];
String tStringArray[] = (String[]) tSObjectArray;   

Quindi tList.toArray sta creando un'istanza di un oggetto e non di stringhe ...

Pertanto, la soluzione naturale che non è stata menzionata in questo thread, ma è ciò che Oracle consiglia è la seguente

String tArray[] = tList.toArray(new String[0]);

Spero sia abbastanza chiaro.

Il framework delle raccolte di google offre una citazione di un buon metodo di trasformazione, in modo da poter trasformare i tuoi oggetti in stringhe. L'unico aspetto negativo è che deve essere da Iterable a Iterable ma questo è il modo in cui lo farei:

Iterable<Object> objects = ....... //Your chosen iterable here
Iterable<String> strings = com.google.common.collect.Iterables.transform(objects, new Function<Object, String>(){
        String apply(Object from){
             return from.toString();
        }
 });

Questo ti allontana dall'uso delle matrici, ma penso che questo sarebbe il mio modo preferito.

Se vuoi ottenere una rappresentazione String degli oggetti nella tua matrice, allora sì, non c'è altro modo per farlo.

Se sai che l'array Object contiene solo stringhe, puoi anche fare (istruzioni per chiamare toString ()):

for (int i=0;i<String_Array.length;i++) String_Array[i]= (String) Object_Array[i];

L'unico caso in cui potresti usare il cast su String [] di Object_Array sarebbe se l'array a cui fa riferimento fosse effettivamente definito come String [], ad esempio questo funzionerebbe:

    Object[] o = new String[10];
    String[] s = (String[]) o;

Questo è carino, ma non funziona come notato da mmyer, a causa delle parentesi quadre:

Arrays.toString(objectArray).split(",")

Questo è brutto ma funziona:

Arrays.toString(objectArray).replaceFirst("^\\[", "").replaceFirst("\\]$", "").split(",")

Se usi questo codice devi essere sicuro che le stringhe restituite dai tuoi oggetti 'toString () non contengono virgole.

Per la tua idea, in realtà ti stai avvicinando al successo, ma se lo fai in questo modo dovrebbe andare bene:

for (int i=0;i<String_Array.length;i++) String_Array[i]=(String)Object_Array[i];

A proposito, l'uso del metodo di utilità Array è abbastanza buono e rende elegante il codice.

Object arr3[]=list1.toArray();
   String common[]=new String[arr3.length];

   for (int i=0;i<arr3.length;i++) 
   {
   common[i]=(String)arr3[i];
  }

È possibile utilizzare il convertitore di tipi . Per convertire un array di qualsiasi tipo in array di stringhe puoi registrare il tuo convertitore:

 TypeConverter.registerConverter(Object[].class, String[].class, new Converter<Object[], String[]>() {

        @Override
        public String[] convert(Object[] source) {
            String[] strings = new String[source.length];
            for(int i = 0; i < source.length ; i++) {
                strings[i] = source[i].toString();
            }
            return strings;
        }
    });

e usalo

   Object[] objects = new Object[] {1, 23.43, true, "text", 'c'};
   String[] strings = TypeConverter.convert(objects, String[].class);

Cambia facilmente senza alcun headche Converti qualsiasi array di oggetti in array di stringhe Oggetto drivex [] = {1,2};

    for(int i=0; i<drive.length ; i++)
        {
            Str[i]= drivex[i].toString();
            System.out.println(Str[i]); 
        }