Como converter uma matriz de objetos em uma string em Java

Eu uso o seguinte código para converter uma matriz de objetos em uma matriz de seqüência de caracteres:

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

Mas eu me pergunto se existe outra maneira de fazer isso, algo como:

String_Array=(String[])Object_Array;

Mas isso causaria um erro de tempo de execução: Exception in thread "AWT-EventQueue-0" java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.String;

Qual é a maneira correta de fazer isso?

Outra alternativa para System.arraycopy:

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

No Java 8:

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

Para converter uma matriz de outros tipos:

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

System.arraycopy é provavelmente a maneira mais eficiente, mas para a estética, eu prefiro:

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

Vejo que algumas soluções foram fornecidas, mas nenhuma causa, por isso explicarei isso em detalhes, pois acredito que é tão importante saber o que você estava fazendo de errado que apenas obter "algo" que funcione a partir das respostas fornecidas.

Primeiro, vamos ver o que a Oracle tem a dizer

 * <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.

Pode não parecer importante, mas como você verá, é ... Então, o que a linha a seguir falha? Todos os objetos da lista são String, mas não os convertem, por quê?

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

Provavelmente, muitos de vocês pensariam que esse código está fazendo o mesmo, mas não o faz.

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

Quando, na realidade, o código escrito está fazendo algo assim. O javadoc está dizendo isso! Instará uma nova matriz, o que será dos objetos !!!

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

Então tList.toArray está instanciando um Objetos e não Strings ...

Portanto, a solução natural que não foi mencionada neste segmento, mas é o que a Oracle recomenda é a seguinte

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

Espero que esteja claro o suficiente.

A estrutura de coleções do google oferece a citação um bom método de transformação, para que você possa transformar seus Objetos em Strings. A única desvantagem é que deve ser de Iterable para Iterable, mas é assim que eu faria:

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

Isso o impede de usar matrizes, mas acho que essa seria a minha maneira preferida.

Se você deseja obter uma representação String dos objetos em sua matriz, sim, não há outra maneira de fazê-lo.

Se você sabe que sua matriz de objetos contém apenas Strings, você também pode fazer isso (em vez de chamar toString ()):

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

O único caso em que você poderia usar o cast para String [] do Object_Array seria se a matriz que ele referencia fosse realmente definida como String [], por exemplo, isso funcionaria:

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

Este é legal, mas não funciona como os mmyers notaram, por causa dos colchetes:

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

Este é feio, mas funciona:

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

Se você usar esse código, verifique se as seqüências retornadas por toString () dos objetos não contêm vírgulas.

Para sua ideia, na verdade você está se aproximando do sucesso, mas se você fizer isso, tudo bem:

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

BTW, o uso do método utilitário Arrays é muito bom e torna o código elegante.

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

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

Você pode usar o conversor de tipos . Para converter uma matriz de qualquer tipo em matriz de cadeias, você pode registrar seu próprio conversor:

 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 use

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

Altere facilmente sem qualquer cabeçalho Converta qualquer matriz de objetos em matriz de objetos Object drivex [] = {1,2};

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