Convertir un tableau de chaînes en une chaîne en Java

Je veux le code Java pour convertir un tableau de chaînes en chaîne.

Si vous voulez juste un vidage "de style débogage" d'un tableau:

String str = Arrays.toString(arr);

ou, pour plus de contrôle (avant Java 8):

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

(Java 8 et supérieur):

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

Et si vous venez sous l'angle Android:

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

Vous pouvez modifier ce qui précède en fonction des caractères, le cas échéant, que vous souhaitez entre les chaînes.

Vous pouvez voir un code presque identique au code pré-Java 8, mais l'utilisation de StringBuffer- StringBuilderest une classe plus récente qui n'est pas adaptée aux threads, mais a donc de meilleures performances dans un seul thread car elle supprime la synchronisation inutile. En bref, il vaut mieux utiliser StringBuilderdans 99% des cas - en termes de fonctionnalité, les deux sont identiques.

N'UTILISEZ PAS de chaîne et ajoutez-la simplement avec + = comme certaines des réponses ici. Cela envoie le GC à travers le toit parce que vous créez et jetez autant d'objets chaîne que vous avez d'éléments dans votre tableau. Pour les petits tableaux, vous ne remarquerez peut-être pas vraiment la différence, mais pour les grands, il peut être plus lent de plusieurs ordres de grandeur.

Utilisez Apache commons StringUtils.join(). Il prend un tableau en tant que paramètre (et a également des surcharges pour Iterableet des Iteratorparamètres) et appelle toString()chaque élément (s'il n'est pas nul) pour obtenir la représentation sous forme de chaîne de chaque élément. Chaque représentation de chaîne d'éléments est ensuite jointe en une chaîne avec un séparateur entre les deux si l'un est spécifié:

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

Produit:

a-b-1

J'aime utiliser Google Joiner Guava pour cela, par exemple:

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

produirait la même chaîne que:

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

ETA: Java 8 dispose désormais d'un support similaire:

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

Je ne vois pas la prise en charge du saut de valeurs nulles, mais cela est facile à contourner.

Vous pouvez le faire, étant donné un tableau ade type primitif:

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

Depuis Java 8, la manière la plus simple, je pense, est:

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

De cette façon, vous pouvez choisir un délimiteur arbitraire.

Essayez la méthode Arrays.deepToString .

Renvoie une représentation sous forme de chaîne du "contenu profond" du tableau spécifié. Si le tableau contient d'autres tableaux en tant qu'éléments, la représentation sous forme de chaîne contient leur contenu, etc. Cette méthode est conçue pour convertir des tableaux multidimensionnels en chaînes

Essayez les méthodes Arrays.toString surchargées.

Sinon, essayez cette implémentation générique ci-dessous:

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

Voici un exemple de conversion de tableau en chaîne.

    public class ArrayToString
    {

        public static void main (String [] args)
        {
            String [] strArray = new 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

Si vous n'avez pas le choix mais d'utiliser Java 6 ou 7, vous devez utiliser la jointure Divide & Conquer.

Vous voulez du code qui produit une chaîne à partir de arrayList,

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

vous pouvez le faire de 2 manières: en utilisant String comme résultat ou StringBuffer / StringBuilder.

Exemple:

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

... mais ce n'est pas une bonne pratique pour des raisons de performances. Mieux vaut utiliser StringBuffer (threads safe) ou StringBuilder qui sont plus appropriés pour ajouter des chaînes

Utilisez la méthode join de la bibliothèque StringUtils d' 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);

Si vous savez combien d'éléments le tableau possède, une méthode simple est la suivante:

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