Cómo convertir una matriz de objetos a una matriz de cadenas en Java

Utilizo el siguiente código para convertir una matriz de objetos en una matriz de cadenas:

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

Pero me pregunto si hay otra forma de hacer esto, algo como:

String_Array=(String[])Object_Array;

Pero esto causaría un error de tiempo de ejecución: Exception in thread "AWT-EventQueue-0" java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.String;

¿Cuál es la forma correcta de hacerlo?

Otra alternativa a System.arraycopy:

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

En Java 8:

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

Para convertir una matriz de otros tipos:

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

System.arraycopy es probablemente la forma más eficiente, pero por estética, prefiero:

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

Veo que se han proporcionado algunas soluciones pero no ninguna causa, por lo que explicaré esto en detalle, ya que creo que es tan importante saber qué estaba haciendo mal que obtener "algo" que funcione a partir de las respuestas dadas.

Primero, veamos qué tiene que decir 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.

Puede que no parezca importante, pero como verá, es ... Entonces, ¿qué falla la siguiente línea? Todos los objetos en la lista son String pero no los convierte, ¿por qué?

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

Probablemente, muchos de ustedes pensarían que este código está haciendo lo mismo, pero no es así.

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

Cuando en realidad el código escrito está haciendo algo como esto. ¡El javadoc lo está diciendo! Instantará una nueva matriz, lo que será de Objetos !!!

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

Entonces tList.toArray está instanciando objetos y no cadenas ...

Por lo tanto, la solución natural que no se ha mencionado en este hilo, pero es lo que recomienda Oracle es la siguiente

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

Espero que sea lo suficientemente claro.

El marco de colecciones de Google ofrece un buen método de transformación para que pueda transformar sus objetos en cadenas. El único inconveniente es que tiene que ser de Iterable a Iterable, pero esta es la forma en que lo haría:

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

Esto te aleja del uso de matrices, pero creo que esta sería mi forma preferida.

Si desea obtener una representación de cadena de los objetos en su matriz, entonces sí, no hay otra forma de hacerlo.

Si sabe que su matriz de Objetos contiene solo Cadenas, también puede hacerlo (instread de llamar a ToString ()):

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

El único caso en el que podría usar la conversión a String [] de Object_Array sería si la matriz a la que hace referencia en realidad se definiría como String [], por ejemplo, esto funcionaría:

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

Este es bueno, pero no funciona como notaron mmyers, debido a los corchetes:

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

Este es feo pero funciona:

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

Si usa este código, debe asegurarse de que las cadenas devueltas por sus objetos 'toString () no contengan comas.

Para tu idea, en realidad te estás acercando al éxito, pero si te gusta esto debería estar bien:

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

Por cierto, usar el método de utilidad Arrays es bastante bueno y hace que el código sea elegante.

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

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

Puedes usar type-converter . Para convertir una matriz de cualquier tipo en una matriz de cadenas, puede registrar su propio convertidor:

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

y úsalo

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

Cambie fácilmente sin ningún encabezado Convierta cualquier matriz de objetos en una matriz de cadenas Object drivex [] = {1,2};

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