web-dev-qa-db-fra.com

Générateur de chaînes vs concaténation de chaînes

Quels sont les avantages et les inconvénients de l'utilisation d'un générateur de chaînes par rapport à la concaténation de chaînes pure?

new StringBuilder(32).append(str1)
                     .append(" test: ")
                     .append(val)
                     .append(" is changed")
                     .toString();

vs dire

str1 + " test: " + val + " is changed".

str1 est une chaîne aléatoire de 10 caractères. str2 est une chaîne aléatoire de 8 caractères.

javastringbuilderstring-concatenation
27
Chun ping Wang

Dans votre exemple particulier, aucun car le compilateur utilise en interne StringBuilders pour effectuer la concaténation de chaînes. Si la concaténation s'est produite dans une boucle, cependant, le compilateur peut créer plusieurs objets StringBuilder et String. Par exemple:

String s= "" ;
for(int i= 0 ; i < 10 ; i++ )
    s+= "a" ;

Chaque fois que la ligne 3 ci-dessus est exécutée, un nouvel objet StringBuilder est créé, le contenu de s ajouté, "a" ajouté, puis le StringBuilder est converti en chaîne à attribuer de nouveau à s. Un total de 10 StringBuilders et 10 Strings.

Inversement, dans

StringBuilder sb= new StringBuilder() ;
for(int i= 0 ; i < 10 ; i++ )
    sb.append( "a" );
String s= sb.toString() ;

Seuls 1 StringBuilder et 1 String sont créés.

La raison principale en est que le compilateur ne peut pas être suffisamment intelligent pour comprendre que la première boucle est équivalente à la seconde et générer un code (octet) plus efficace. Dans des cas plus complexes, il est impossible même pour le compilateur le plus intelligent de savoir. Si vous avez absolument besoin de cette optimisation, vous devez l'introduire manuellement en utilisant explicitement StringBuilders.

52
Mario Rossi

La réponse rapide est la performance: lorsque vous utilisez des classes String natives, il utilise des chaînes immuables, ce qui signifie que lorsque vous écrivez

  String line = "Java";
  String sufix = " is awesome";
  line = line + sufix;

il créera deux chaînes "Java" et "is awesome", que créera une nouvelle troisième chaîne "Java is awesome" des deux précédentes ("Java" et "is awesome") qui plus tard seront probablement supprimées par un garbage collector ( car ils ne sont plus utilisés dans l'application). C'est une solution lente.

Une solution plus rapide est un appareil de la classe StringBuffer qui, grâce aux algorithmes intelligents qui fournissent un tampon (qui est évident d'après son nom) pour fusionner les chaînes et, par conséquent, ne supprimerait pas la chaîne initiale pendant le processus de concaténation.

Dans le cas où vous écrivez une application de thread unique (pas de problèmes de concordance pendant lesquels plusieurs threads accèdent au même objet), il est préférable d'appliquer StringBuilder qui a des performances encore plus rapides que la classe StringBuffer initiale.

5
user2487119