Pourquoi String est préférable à StringBuilder en concaténation?

Question

Ma méthode ci-dessous doit renvoyer une chaîne concaténée à partir de chaînes.

StringBuilder sb = new StringBuilder(); 
sb.append("count: ").append(this.count()).append("\n"); 

return sb.toString(); 

En IntelliJ, le code d'inspection me suggère de remplacer ce StringBuilder avec une chaîne comme ci-dessous:

String sb = "count: " + this.count() + "\n"; 
return sb 

Mon impression est que StringBuilder doit être utilisé avec la méthode append, pour remplacer concaténation de chaîne avec le signe plus. Cette suggestion d'inspection de code a-t-elle un sens dans IntelliJ?

Answer 1

Vous avez raison dans vos présomptions que la plupart des inspections IntelliJ vous encouragent à faire les choses de façon "meilleure".

Cependant, ce n'est pas toujours le cas. Surtout lorsque certaines inspections fonctionnent «dans les deux sens» -> vous devrez exercer votre propre jugement sur ce qui est «meilleur».

Dans ce cas, si vous commencez avec une chaîne concaténée normale:

return "count: " + count + "\n"; 

Il y a quelques inspections disponibles - curseur mis sur "count: " et appuyez sur Alt-Entrée:

1. Remplacer « + 'avec String.format()
2. Remplacer '+' avec StringBuilder.append()
3. Remplacer '+' avec java.text.MessageFormat.format()

Si vous choisissez l'option (2), vous obtenez ceci:

return new StringBuilder().append("count: ").append(count).append("\n").toString(); 

Maintenant, vous pouvez utiliser alt-entrer à nouveau pour choisir "Remplacer StringBuilder avec la chaîne" inverser le changement.

Dans ce cas, vous avez découvert une inspection/refactoring bidirectionnelle: cela fonctionne dans les deux sens. D'autres refactorings (tels que "Encapsulate") ne fonctionnent que d'une seule façon.

Quant à ce qui est « meilleur » - vous devez peser les performances de StringBuilder par rapport à la lisibilité et la simplicité, et faire ce jugement vous - IntelliJ est simplement fournir des inspections à portée de main pour vous aider;)