Verketten von Elementen in einem Array zu einer Zeichenfolge

Arrays.toString(arr);

ausgabe ist [1,2,3] und Sie speichern es in Ihrer Zeichenfolge. und drucken, so dass Sie eine Ausgabe erhalten [1,2,3].

Wenn Sie die Ausgabe 123 erhalten möchten, versuchen Sie Folgendes:

public static void main(String[] args) {
    String[] arr= {"1","2","3"};
    String output ="";
    for(String str: arr)
        output=output+str;
    System.out.println(output);


}

Ausgabe:

123

Einfache antwort:

Arrays.toString(arr);

Verwenden Sie die Funktion Arrays.toString (). Es hält Ihren Code kurz und lesbar. Es verwendet intern einen String-Builder und ist daher auch effizient. Um die zusätzlichen Zeichen zu entfernen, können Sie sie mit der Funktion String.replace () entfernen, was allerdings die Lesbarkeit wieder verringert.

String str = Arrays.toString(arr).replaceAll(", |\\[|\\]", "");

Dies ist der Antwort von Tris Nefzger ähnlich, jedoch ohne die langwierige Konstruktion der Unterzeichenfolge, um die eckigen Klammern zu beseitigen. 

Erklärung des Regex: "|" bedeutet "," und "[" und "]". Das "\\" sagt dem Java-String, dass wir kein Sonderzeichen (wie eine neue Zeile "\ n" oder ein Tab "\ t") bedeuten, sondern einen echten Backslash "\". Statt "\\ [" liest der Regex-Interpreter "\ [". Dies bedeutet, dass wir eine wörtliche eckige Klammer meinen und diese nicht als Teil der Regex-Sprache verwenden möchten (zum Beispiel "[ ^ 3] * "bezeichnet eine beliebige Anzahl von Zeichen, aber keines sollte" 3 "sein. 

Arrays.toString: (aus der API, zumindest für die Object[]-Version davon)

public static String toString(Object[] a) {
    if (a == null)
        return "null";
    int iMax = a.length - 1;
    if (iMax == -1)
        return "[]";

    StringBuilder b = new StringBuilder();
    b.append('[');
    for (int i = 0; ; i++) {
        b.append(String.valueOf(a[i]));
        if (i == iMax)
            return b.append(']').toString();
        b.append(", ");
    }
}

Das heißt, es fügt den [ am Anfang, den ] am Ende und den , zwischen den Elementen ein.

Wenn du es ohne diese Zeichen willst: (StringBuilder ist schneller als der folgende, aber es kann nicht die kleine Menge an Code sein)

String str = "";
for (String i:arr)
  str += i;
System.out.println(str);

Randnotiz:

String[] arr[3]= [1,2,3] wird nicht kompiliert.

Vermutlich wollten Sie: String[] arr = {"1", "2", "3"};

Tun Sie es Java 8-fach in nur 1 Zeile:

String.join("", arr);

Guava hat das Joiner-Dienstprogramm, um dieses Problem zu beheben:

Beispiel:

String joinWithoutSeparator = Joiner.on("").join(1, 2, 3); // returns "123"
String joinWithSeparator = Joiner.on(",").join(1, 2, 3); // returns "1,2,3"

Ich habe gerade folgendes geschrieben:

public static String toDelimitedString(int[] ids, String delimiter)
{
    StringBuffer strb = new StringBuffer();
    for (int id : ids)
    {
      strb.append(String.valueOf(id) + delimiter);
    }
    return strb.substring(0, strb.length() - delimiter.length());
 }

Verwenden von Guavas Joiner (das in r18 intern StringBuilder verwendet)

String[]  arr= {"1","2","3"};
Joiner noSpaceJoiner = Joiner.on("");
noSpaceJoiner.join(arr))

Joiner ist nützlich, da es Thread-sicher und unveränderlich ist und an vielen Stellen wiederverwendet werden kann, ohne dass Code kopiert werden muss. Meiner Meinung nach ist es auch lesbarer.

Mit der Unterstützung von Java 8 Stream / können wir dies auch auf einen Einzeiler reduzieren.

String concat = Stream.of(arr).collect(Collectors.joining());

Beide Ausgänge sind in diesem Fall 123

Dies ist ein kleiner Code zum Konvertieren eines String-Arrays in einen String ohne [ oder ] oder ,

String[] strArray = new String[]{"Java", "String", "Array", "To", "String", "Example"};

String str = Arrays.toString(strArray);
            str = str.substring(1, str.length()-1).replaceAll(",", "");

• Konvertieren Sie zuerst das Array in einen String.
• Zweitens erhalten Sie Text von der x- zur y-Position.
• 3. Ersetzen Sie alle "," durch "".

Für Frühlingsprojekte:

org.springframework.util.StringUtils.arrayToDelimitedString (Object [] arr, String delim)

Für Apache Commons-Benutzer eine Reihe von Nice-Join-Methoden:

org.Apache.commons.lang.StringUtils.join (Object [] -Array, Zeichenseparator)

Arrays.toString formatiert die Ausgabe (fügte die Klammern und Kommas hinzu). Sie sollten Ihre eigene Methode von toString implementieren.

public String toString(String[] arr){
    String result = "";
    for(String s : arr)
        result+=s;
    return result;
}

[edit] Stringbuilder ist jedoch besser. siehe oben.

sehen Sie sich die generische Methode an, um alle Elemente in einem Array zu drucken.

kurz gesagt: Arrays.toString (arr) ist nur eine einfache Möglichkeit, den Inhalt eines primären Arrays zu drucken.

Objektklasse hat toString-Methode. Alle anderen Klassen, die es erweitern, überschreiben die toString-Methode, so dass in Arrays auch toString auf diese Weise überschrieben wird. Wenn Sie also Ihre Ausgabe nach Ihren Wünschen gestalten möchten, müssen Sie eine eigene Methode erstellen, mit der Sie das gewünschte Ergebnis erhalten.

str="";
for (Integer i:arr){
     str+=i.toString();
}

Hoffe das hilft

refer Warum scheint die toString-Methode in Java für ein Array nicht zu funktionieren

Arrays.toString () kann verwendet werden, um String Array in String umzuwandeln. Die zusätzlichen Zeichen können mit Regex-Ausdrücken oder einfach mit der replace-Methode entfernt werden.

Arrays.toString(strArray).replace(",", "").replace("[", "").replace("]", "");

Java 8 hat eine neue Methode für den String-Join eingeführt.

String.join("", strArray);

Hier ist eine Möglichkeit, dies zu tun: Arrays.toString (array )Substring (1, (3 * array.length-1)). ReplaceAll (",", "");

Hier ist eine Demo-Klasse:

package arraytostring.demo;

import Java.util.Arrays;

public class Array2String {

        public static void main(String[] args) {

                String[] array = { "1", "2", "3", "4", "5", "6", "7" };
                System.out.println(array2String(array));
                // output is: 1234567
        }

        public static String array2String(String[] array) {

                return Arrays.toString(array).substring(1, (3 * array.length - 1))
                                .replaceAll(", ", "");

        }

}

Scala macht das einfacher, sauberer und sicherer:

scala> val a = Array("1", "2", "3")
a: Array[String] = Array(1, 2, 3)

scala> val aString = a.mkString
aString: String = 123

scala> println(aString)
123

Beispiel mit Java 8.

  String[] arr = {"1", "2", "3"};
  String join = String.join("", arr);

Ich hoffe das hilft

Für diejenigen, die in Android entwickeln, verwenden Sie TextUtils.

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

Angenommen, arr ist vom Typ String[] arr= {"1","2","3"};

Die Ausgabe wäre 123