So konvertieren Sie ein Objektarray in ein Stringarray in Java

Ich verwende den folgenden Code, um ein Object-Array in ein String-Array zu konvertieren:

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

Aber ich frage mich, ob es einen anderen Weg gibt, so etwas wie:

String_Array=(String[])Object_Array;

Dies würde jedoch einen Laufzeitfehler verursachen: Exception in thread "AWT-EventQueue-0" java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.String;

Was ist der richtige Weg, um es zu tun?

Eine weitere Alternative zu System.arraycopy:

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

In Java 8:

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

So konvertieren Sie ein Array anderer Typen:

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

System.arraycopy ist wahrscheinlich der effizienteste Weg, aber aus ästhetischen Gründen würde ich Folgendes bevorzugen:

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

Ich sehe, dass einige Lösungen bereitgestellt wurden, aber keine Ursachen, daher werde ich dies ausführlich erläutern, da ich glaube, dass es genauso wichtig ist zu wissen, was Sie falsch gemacht haben, nur um "etwas" zu erhalten, das aus den gegebenen Antworten funktioniert.

Lassen Sie uns zunächst sehen, was Oracle zu sagen hat

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

Es mag nicht wichtig aussehen, aber wie Sie sehen werden, ist es ... Also, was schlägt die folgende Zeile fehl? Alle Objekte in der Liste sind Zeichenfolgen, werden jedoch nicht konvertiert. Warum?

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

Wahrscheinlich würden viele von Ihnen denken, dass dieser Code dasselbe tut, aber das tut er nicht.

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

In Wirklichkeit macht der geschriebene Code so etwas. Der Javadoc sagt es! Es wird ein neues Array initiieren, was es von Objekten sein wird !!!

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

Also instanziiert tList.toArray ein Objekt und keine Zeichenfolgen ...

Daher ist die natürliche Lösung, die in diesem Thread nicht erwähnt wurde, aber von Oracle empfohlen wird, die folgende

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

Hoffe es ist klar genug.

Das Google-Sammlungsframework bietet eine gute Transformationsmethode, mit der Sie Ihre Objekte in Zeichenfolgen umwandeln können. Der einzige Nachteil ist, dass es von Iterable zu Iterable sein muss, aber so würde ich es machen:

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

Dies nimmt Sie von der Verwendung von Arrays ab, aber ich denke, dies wäre mein bevorzugter Weg.

Wenn Sie eine String-Darstellung der Objekte in Ihrem Array erhalten möchten, gibt es keine andere Möglichkeit.

Wenn Sie wissen, dass Ihr Object-Array nur Strings enthält, können Sie dies auch tun (anstelle des Aufrufs von toString ()):

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

Der einzige Fall, in dem Sie die Umwandlung in String [] des Object_Array verwenden könnten, wäre, wenn das Array, auf das es verweist, tatsächlich als String [] definiert wäre, z. B. würde dies funktionieren:

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

Dieser ist nett, funktioniert aber aufgrund der eckigen Klammern nicht so, wie mmyers bemerkt hat:

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

Dieser ist hässlich, funktioniert aber:

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

Wenn Sie diesen Code verwenden, müssen Sie sicherstellen, dass die von toString () Ihrer Objekte zurückgegebenen Zeichenfolgen keine Kommas enthalten.

Für Ihre Idee nähern Sie sich tatsächlich dem Erfolg, aber wenn Sie dies mögen, sollte es in Ordnung sein:

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

Übrigens ist die Verwendung der Dienstprogrammmethode Arrays recht gut und macht den Code elegant.

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

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

Sie können den Typkonverter verwenden . Um ein Array eines beliebigen Typs in ein Array von Zeichenfolgen zu konvertieren, können Sie Ihren eigenen Konverter registrieren:

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

und benutze es

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

Einfach ohne Kopf ändern Ändern Sie ein Objektarray in ein Zeichenfolgenarray. Objekt drivex [] = {1,2};

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