Comment convertir un tableau d'objets en tableau de chaînes en Java

J'utilise le code suivant pour convertir un tableau d'objets en un tableau de chaînes:

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

Mais je me demande s'il y a une autre façon de procéder, quelque chose comme:

String_Array=(String[])Object_Array;

Mais cela provoquerait une erreur d'exécution: Exception in thread "AWT-EventQueue-0" java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.String;

Quelle est la bonne façon de procéder?

Une autre alternative à System.arraycopy:

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

En Java 8:

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

Pour convertir un tableau d'autres types:

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

System.arraycopy est probablement le moyen le plus efficace, mais pour l'esthétique, je préfère:

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

Je vois que certaines solutions ont été fournies mais pas de cause, je vais donc expliquer cela en détail car je pense qu'il est aussi important de savoir ce que vous faisiez de mal que juste pour obtenir "quelque chose" qui fonctionne à partir des réponses données.

Voyons d'abord ce qu'Oracle a à dire

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

Cela peut ne pas sembler important, mais comme vous le verrez, alors ... Qu'est-ce que la ligne suivante échoue? Tous les objets de la liste sont String mais il ne les convertit pas, pourquoi?

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

Beaucoup d'entre vous penseraient probablement que ce code fait de même, mais ce n'est pas le cas.

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

Quand en réalité le code écrit fait quelque chose comme ça. Le javadoc le dit! Il va créer un nouveau tableau, ce que ce sera des objets !!!

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

Donc, tList.toArray instancie un objet et non une chaîne ...

Par conséquent, la solution naturelle qui n'a pas été mentionnée dans ce fil, mais c'est ce que recommande Oracle est la suivante

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

J'espère que c'est assez clair.

Le cadre des collections Google propose de citer une bonne méthode de transformation, afin que vous puissiez transformer vos objets en chaînes. Le seul inconvénient est que cela doit être de Iterable à Iterable mais c'est la façon dont je le ferais:

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

Cela vous éloigne de l'utilisation des tableaux, mais je pense que ce serait ma façon préférée.

Si vous souhaitez obtenir une représentation String des objets de votre tableau, alors oui, il n'y a pas d'autre moyen de le faire.

Si vous savez que votre tableau d'objets contient uniquement des chaînes, vous pouvez également le faire (au lieu d'appeler toString ()):

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

Le seul cas où vous pourriez utiliser le transtypage en String [] de Object_Array serait si le tableau auquel il fait référence était réellement défini comme String [], par exemple, cela fonctionnerait:

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

Celui-ci est agréable, mais ne fonctionne pas comme l'ont remarqué mmyers, à cause des crochets:

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

Celui-ci est moche mais fonctionne:

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

Si vous utilisez ce code, vous devez être sûr que les chaînes retournées par toString () de vos objets ne contiennent pas de virgules.

Pour votre idée, en fait, vous approchez du succès, mais si vous aimez cela, ça devrait aller:

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

BTW, en utilisant la méthode utilitaire Arrays est assez bon et rend le code élégant.

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

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

Vous pouvez utiliser un convertisseur de type . Pour convertir un tableau de n'importe quel type en tableau de chaînes, vous pouvez enregistrer votre propre convertisseur:

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

et l'utiliser

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

Changez facilement sans aucun headche Convertissez n'importe quel tableau d'objets en tableau de chaînes Object drivex [] = {1,2};

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