J'essaie de comprendre quelle est la meilleure pratique et pourquoi pour concaténer des littéraux de chaîne et des variables pour différents cas. Par exemple, si j'ai un code comme celui-ci

StringBuilder sb = new StringBuilder("AAAAAAAAAAAAA")
    .append(B_String).append("CCCCCCCCCCC").append(D_String)
    .append("EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE")
    .append("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");

Est-ce la manière de procéder? À partir de cet article , j'ai remarqué que l' +opérateur sur Strings crée une nouvelle instance de StringBuilder, concatène les opérandes et renvoie une conversion de chaîne, ce qui semble beaucoup plus de travail que d'appeler .append(); donc si c'est vrai, alors c'est hors de question. Mais qu'en est-il String.concat()? Est-il approprié d'utiliser .append()pour chaque concaténation? Ou juste pour les variables, et les littéraux peuvent être ajoutés .concat()?

StringBuilder sb = new StringBuilder("AAAAAAAAAAAAA")
    .append(B_String.concat("CCCCCCCCCCC")).append(D_String
    .concat("EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE")
    .concat("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"));

Quelles sont les règles générales de bonnes pratiques et de performances pour faire face à ces situations? Mon hypothèse est-elle correcte +et ne devrait-elle tout simplement pas être utilisée?

+ opérateur

String s = s1 + s2

Dans les coulisses, cela se traduit par:

String s = new StringBuilder(s1).append(s2).toString();

Imaginez combien de travail supplémentaire cela ajoute si vous avez s1 + s2ici:

stringBuilder.append(s1 + s2)

au lieu de:

stringBuilder.append(s1).append(s2)

Plusieurs chaînes avec +

Il convient de noter que:

String s = s1 + s2 + s3 + ... +sN

se traduit par:

String s = new StringBuilder(s1).append(s2).append(s3)...apend(sN).toString();

concat()

String s = s1.concat(s2);

Stringcrée un char[]tableau qui peut s'adapter à la fois s1et s2. Copie s1et s2contenu dans ce nouveau tableau. Nécessite en fait moins de travail que l' +opérateur.

StringBuilder.append()

Maintient une char[]matrice interne qui se développe en cas de besoin. Aucun supplément char[]n'est créé si l'intérieur est suffisamment grand.

stringBuilder.append(s1.concat(s2))

fonctionne également mal car s1.concat(s2)crée un char[]tableau supplémentaire et des copies s1et s2vers celui-ci simplement pour copier ce nouveau contenu de tableau en interne StringBuilder char[].

Cela étant dit, vous devez utiliser append()tout le temps et ajouter des chaînes brutes (votre premier extrait de code est correct).

Le compilier optimise la concaténation +.

Donc

int a = 1;
String s = "Hello " + a;

se transforme en

new StringBuilder().append("Hello ").append(1).toString();

Il existe un excellent sujet ici expliquant pourquoi vous devriez utiliser l'opérateur +.

L'optimisation est effectuée automatiquement par le compilateur.

Le compilateur Java2 convertira automatiquement les éléments suivants:

String s = s1 + s2; 

à

String s = (new StringBuffer()).append(s1).append(s2).toString();

Tiré directement du site Web Java Best Practices on Oracles.

Vous devriez toujours utiliser append.

concatcréer une nouvelle chaîne donc c'est assez comme +je pense.

Si vous concatou utilisez +avec 2 final String, la JVM peut effectuer une optimisation, c'est donc la même chose que d'ajouter dans ce cas.

Si vous concattez exactement deux chaînes, utilisez String.concat (crée une nouvelle chaîne en créant un nouveau tableau de caractères qui correspond aux deux chaînes et y copie les tableaux de caractères des deux chaînes).

Si vous concattez plusieurs chaînes (plus de deux) sur une seule ligne, utilisez + ou StringBuilder.append, cela n'a pas d'importance, car le compilateur convertit + en StringBuilder.append. C'est bon pour plusieurs chaînes car il maintient un tableau de caractères qui se développe selon les besoins.

Si vous concattez plusieurs chaînes sur plusieurs lignes, créez un StringBuilder et utilisez la méthode append. À la fin, lorsque vous avez terminé d'ajouter des chaînes au StringBuilder, utilisez la méthode .toString () pour en créer une chaîne. Pour la concatation sur plusieurs lignes, c'est plus rapide que la deuxième méthode, car la deuxième méthode créerait un nouveau StringBuilder sur chaque ligne, ajouterait les chaînes, puis reconstituerait String, tandis que la troisième méthode n'utilise qu'un seul StringBuilder pour l'ensemble.

Utiliser l' +opérateur est la meilleure pratique, il est également simple et lisible.

Le langage Java fournit un support spécial pour l'opérateur de concaténation de chaînes (+) et pour la conversion d'autres objets en chaînes. La concaténation de chaînes est implémentée via la classe StringBuilder (ou StringBuffer) et sa méthode append.

Document officiel: https://docs.oracle.com/javase/8/docs/api/java/lang/String.html

au niveau du code d'octet, il n'y a pas de différence et nous n'y compromettons pas l'efficacité. En cas d'exécution au niveau du code d'octet, il doit passer par la méthode de surcharge d'opérateur non en ligne pour + en appelant append. puis au niveau du langage assembleur (Java est écrit en C et C produit des assemblys similaires à l'assembly, il y aura un appel de registre supplémentaire pour stocker + appel de méthode dans la pile et il y aura un push supplémentaire. (en réalité, le compilateur croisé pourrait optimiser + opérateur appel, dans ce cas, cela ne fait aucune différence avec efficacité.)

C'est une bonne pratique d'avoir un moyen d'augmenter la lisibilité. :)

Personnellement, je préfère le formateur de chaînes d'Strings.format() une ligne simple et facile à lire .

String b = "B value";
String d = "D value";
String fullString = String.format("A %s C %s E F", b, d);
// Output: A B value C D value E F

Toutes les réponses sont assez bonnes et explicatives. Mais j'ai senti que l'exploration d'autres techniques de concaténation de chaînes aiderait également - Guava Joiner, Streams, String.format, etc.

Pour des détails complets sur les performances de chaque technique de concaténation, java-string-concatenation-which-way-is-best .

En bref, les performances de concaténation varient sans. de chaînes à concaténer. Par exemple - pour concaténer 1 à 10 chaînes, ces techniques fonctionnent le mieux - StringBuilder, StringBuffer et Plus Operator. Et pour concaténer des centaines de chaînes - Guava Joiner, la bibliothèque stringsUtils d'Apache fonctionne également très bien.

Veuillez parcourir le blog ci-dessus. Cela explique vraiment très bien l'efficacité des performances.

Merci.