Java Language Concaténation de chaînes et StringBuilders


Exemple

La concaténation de chaînes peut être effectuée à l'aide de l'opérateur + . Par exemple:

String s1 = "a";
String s2 = "b";
String s3 = "c";
String s = s1 + s2 + s3; // abc

Normalement, une implémentation du compilateur effectuera la concaténation ci-dessus en utilisant des méthodes impliquant un StringBuilder sous le capot. Une fois compilé, le code ressemblerait à celui ci-dessous:

StringBuilder sb = new StringBuilder("a");
String s = sb.append("b").append("c").toString();

StringBuilder dispose de plusieurs méthodes surchargées pour ajouter différents types, par exemple, pour ajouter un int au lieu d'une String . Par exemple, une implémentation peut convertir:

String s1 = "a";
String s2 = "b";    
String s = s1 + s2 + 2; // ab2

à ce qui suit:

StringBuilder sb = new StringBuilder("a");
String s = sb.append("b").append(2).toString();

Les exemples ci-dessus illustrent une opération de concaténation simple effectuée efficacement à un seul endroit du code. La concaténation implique une seule instance de StringBuilder . Dans certains cas, une concaténation est effectuée de manière cumulative, par exemple dans une boucle:

String result = "";
for(int i = 0; i < array.length; i++) {
    result += extractElement(array[i]);
}
return result;

Dans de tels cas, l'optimisation du compilateur n'est généralement pas appliquée et chaque itération crée un nouvel objet StringBuilder . Cela peut être optimisé en transformant explicitement le code pour utiliser un seul StringBuilder :

StringBuilder result = new StringBuilder();
for(int i = 0; i < array.length; i++) {
    result.append(extractElement(array[i]));
}
return result.toString();

Un StringBuilder sera initialisé avec un espace vide de 16 caractères seulement. Si vous savez à l'avance que vous allez créer des chaînes plus grandes, il peut être utile de l'initialiser suffisamment à l'avance pour que le tampon interne n'ait pas besoin d'être redimensionné:

StringBuilder buf = new StringBuilder(30); // Default is 16 characters
buf.append("0123456789");
buf.append("0123456789"); // Would cause a reallocation of the internal buffer otherwise
String result = buf.toString(); // Produces a 20-chars copy of the string

Si vous produisez de nombreuses chaînes, il est conseillé de réutiliser StringBuilder :

StringBuilder buf = new StringBuilder(100);
for (int i = 0; i < 100; i++) {
    buf.setLength(0); // Empty buffer
    buf.append("This is line ").append(i).append('\n');
    outputfile.write(buf.toString());
}

Si (et seulement si) plusieurs threads écrivent dans le même tampon, utilisez StringBuffer , qui est une version synchronized de StringBuilder . Mais comme un seul thread écrit généralement dans un tampon, il est généralement plus rapide d'utiliser StringBuilder sans synchronisation.

Utilisation de la méthode concat ():

String string1 = "Hello ";
String string2 = "world";
String string3 = string1.concat(string2);  // "Hello world"

Cela retourne une nouvelle chaîne qui est string1 avec string2 ajouté à la fin. Vous pouvez également utiliser la méthode concat () avec des littéraux de chaîne, comme dans:

"My name is ".concat("Buyya");