Konvertieren Sie ein Array von Zeichenfolgen in eine Zeichenfolge in Java

Ich möchte den Java-Code zum Konvertieren eines Arrays von Strings in einen String.

Wenn Sie nur einen "Debug-Stil" -Dump eines Arrays möchten:

String str = Arrays.toString(arr);

oder für mehr Kontrolle (vor Java 8):

StringBuilder builder = new StringBuilder();
for(String s : arr) {
    builder.append(s);
}
String str = builder.toString();

(Java 8 und höher):

String str = String.join(",", arr);

Und wenn Sie aus dem Android-Blickwinkel kommen:

String str = TextUtils.join(",", arr);

Sie können die obigen Angaben ändern, je nachdem, welche Zeichen zwischen den Zeichenfolgen gegebenenfalls gewünscht werden.

Möglicherweise sehen Sie nahezu identischen Code wie der Code vor Java 8, verwenden jedoch StringBuffer- StringBuilderist eine neuere Klasse, die nicht threadsicher ist, jedoch eine bessere Leistung in einem einzelnen Thread aufweist, da nicht benötigte Synchronisierungen vermieden werden. Kurz gesagt, Sie verwenden es StringBuilderin 99% der Fälle besser - in Bezug auf die Funktionalität sind beide identisch.

NICHT eine Zeichenfolge verwenden und nur append , um es mit + = wie einige der Antworten hier zeigen. Dadurch wird der GC durch das Dach gesendet, da Sie so viele Zeichenfolgenobjekte erstellen und wegwerfen, wie Sie Elemente in Ihrem Array haben. Bei kleinen Arrays fällt der Unterschied möglicherweise nicht wirklich auf, bei großen kann er jedoch um Größenordnungen langsamer sein.

Verwenden Sie Apache Commons StringUtils.join(). Es nimmt ein Array als Parameter (und hat auch Überladungen für Iterableund IteratorParameter) und ruft toString()jedes Element auf (wenn es nicht null ist), um die Zeichenfolgendarstellung jedes Elements abzurufen. Jede Element-Zeichenfolgendarstellung wird dann zu einer Zeichenfolge mit einem dazwischen liegenden Trennzeichen verbunden, sofern eines angegeben ist:

String joinedString = StringUtils.join(new Object[]{"a", "b", 1}, "-");
System.out.println(joinedString);

Produziert:

a-b-1

Ich verwende dafür gerne Googles Guava Joiner , z.

Joiner.on(", ").skipNulls().join("Harry", null, "Ron", "Hermione");

würde den gleichen String erzeugen wie:

new String("Harry, Ron, Hermione");

ETA: Java 8 unterstützt jetzt ähnlich:

String.join(", ", "Harry", "Ron", "Hermione");

Unterstützung für das Überspringen von Nullwerten wird nicht angezeigt, aber das lässt sich leicht umgehen.

Sie können dies bei einem Array aprimitiven Typs tun :

StringBuffer result = new StringBuffer();
for (int i = 0; i < a.length; i++) {
   result.append( a[i] );
   //result.append( optional separator );
}
String mynewstring = result.toString();

Von Java 8 aus denke ich am einfachsten:

    String[] array = { "cat", "mouse" };
    String delimiter = "";
    String result = String.join(delimiter, array);

Auf diese Weise können Sie ein beliebiges Trennzeichen auswählen.

Probieren Sie die Arrays.deepToString- Methode aus.

Gibt eine Zeichenfolgendarstellung des "tiefen Inhalts" des angegebenen Arrays zurück. Wenn das Array andere Arrays als Elemente enthält, enthält die Zeichenfolgendarstellung deren Inhalt usw. Diese Methode dient zum Konvertieren mehrdimensionaler Arrays in Zeichenfolgen

Probieren Sie die überladenen Methoden Arrays.toString aus .

Oder versuchen Sie Folgendes unter der allgemeinen Implementierung:

public static void main(String... args) throws Exception {

    String[] array = {"ABC", "XYZ", "PQR"};

    System.out.println(new Test().join(array, ", "));
}

public <T> String join(T[] array, String cement) {
    StringBuilder builder = new StringBuilder();

    if(array == null || array.length == 0) {
        return null;
    }

    for (T t : array) {
        builder.append(t).append(cement);
    }

    builder.delete(builder.length() - cement.length(), builder.length());

    return builder.toString();
}

Im Folgenden finden Sie ein Beispiel für die Konvertierung von Array in String.

    öffentliche Klasse ArrayToString
    {

        public static void main (String [] args)
        {
            String [] strArray = neuer String [] {"Java", "PHP", ".NET", "PERL", "C", "COBOL"};


        String newString = Arrays.toString(strArray);

        newString = newString.substring(1, newString.length()-1);

        System.out.println("New New String: " + newString);
    }
}

String[] strings = new String[25000];
for (int i = 0; i < 25000; i++) strings[i] = '1234567';

String result;
result = "";
for (String s : strings) result += s;
//linear +: 5s

result = "";
for (String s : strings) result = result.concat(s);
//linear .concat: 2.5s

result = String.join("", strings);
//Java 8 .join: 3ms

Public String join(String delimiter, String[] s)
{
    int ls = s.length;
    switch (ls)
    {
        case 0: return "";
        case 1: return s[0];
        case 2: return s[0].concat(delimiter).concat(s[1]);
        default:
            int l1 = ls / 2;
            String[] s1 = Arrays.copyOfRange(s, 0, l1); 
            String[] s2 = Arrays.copyOfRange(s, l1, ls); 
            return join(delimiter, s1).concat(delimiter).concat(join(delimiter, s2));
    }
}
result = join("", strings);
// Divide&Conquer join: 7ms

Wenn Sie nicht die Wahl haben, aber Java 6 oder 7 zu verwenden, sollten Sie Divide & Conquer Join verwenden.

Sie möchten Code, der eine Zeichenfolge aus arrayList erzeugt.

Iterate through all elements in list and add it to your String result

Sie können dies auf zwei Arten tun: Verwenden von String als Ergebnis oder StringBuffer / StringBuilder.

Beispiel:

String result = "";
for (String s : list) {
    result += s;
}

... aber dies ist aus Leistungsgründen keine gute Praxis. Besser ist es, StringBuffer (threadsicher) oder StringBuilder zu verwenden, die besser zum Hinzufügen von Strings geeignet sind

Verwenden Sie die Join-Methode der StringUtils-Bibliothek von Apache Commons .

String[] stringArray = {"a","b","c"};
StringUtils.join(stringArray, ",");

String array[]={"one","two"};
String s="";

for(int i=0;i<array.length;i++)
{
  s=s+array[i];
}

System.out.print(s);

Wenn Sie wissen, wie viele Elemente das Array enthält, können Sie dies auf einfache Weise tun:

String appendedString = "" + array[0] + "" + array[1] + "" + array[2] + "" + array[3];