Est-il toujours une mauvaise idée d'utiliser + pour concaténer des chaînes

Question

J'ai le code comme suit:

String s = ""; 
for (My my : myList) { 
    s += my.getX(); 
} 

Findbugs signale toujours une erreur quand je fais cela.

Answer 1

J'utiliser + si vous manuellement concaténez,

String word = "Hello"; 
word += " World!"; 

Cependant, si vous êtes j'itérez et concaténer suggère StringBuilder,

StringBuilder sb = new StringBuilder(); 
for (My my : myList) { 
    sb.append(my.getX()); 
} 

Answer 2

L'objet String est immuable dans Java. Chaque + signifie un autre objet. Vous pouvez utiliser StringBuffer pour réduire la quantité d'objets créés.

Answer 3

Le compilateur peut optimiser quelque chose, comme

"foo" + "bar"

À

StringBuilder s1 = nouveau StringBuilder(); s1.append ("foo"). Append ("bar");

Cependant, ceci est encore sous-optimal puisqu'il commence avec une taille par défaut de 16. Comme avec beaucoup de choses bien que vous devriez trouver votre plus grand col de bouteille et descendre votre liste. Cela ne fait pas de mal d'être dans l'habitude d'utiliser un pattern SB dès le départ, surtout si vous êtes capable de calculer une taille d'initialisation optimale.

Answer 4

L'optimisation prématurée peut être mauvaise, elle réduit souvent la lisibilité et est généralement inutile. Utilisez + s'il est plus lisible sauf si vous avez réellement une préoccupation majeure.

Answer 5

Il n'est pas 'toujours mauvais' d'utiliser "+". Utiliser StringBuffer partout peut rendre le code vraiment encombrant.

Si quelqu'un mettait beaucoup de «+» au milieu d'une boucle intensive et critique, je serais ennuyé. Si quelqu'un met beaucoup de «+» dans un code rarement utilisé, je m'en fiche.

Answer 6

Je dirais que l'utilisation plus dans ce qui suit:

String c = "a" + "b"

Et utiliser la classe StringBuilder partout ailleurs. Comme déjà mentionné dans le premier cas, il sera optimisé par le compilateur et il est plus lisible.

Answer 7

Chaque fois que vous faites string+=string, il appelle la méthode comme ceci:

private String(String s1, String s2) { 
    if (s1 == null) { 
     s1 = "null"; 
    } 
    if (s2 == null) { 
     s2 = "null"; 
    } 
    count = s1.count + s2.count; 
    value = new char[count]; 
    offset = 0; 
    System.arraycopy(s1.value, s1.offset, value, 0, s1.count); 
    System.arraycopy(s2.value, s2.offset, value, s1.count, s2.count); 
} 

En cas de StringBuilder, il vient:

final void append0(String string) { 
    if (string == null) { 
     appendNull(); 
     return; 
    } 
    int adding = string.length(); 
    int newSize = count + adding; 
    if (newSize > value.length) { 
     enlargeBuffer(newSize); 
    } 
    string.getChars(0, adding, value, count); 
    count = newSize; 
} 

Comme vous pouvez clairement conclure, string + string crée beaucoup de frais généraux, et à mon avis devrait être évité si possible.Si vous pensez que l'aide StringBuilder est volumineux ou longue, vous pouvez juste faire une méthode et de l'utiliser indirectement, comme:

public static String scat(String... vargs) { 
    StringBuilder sb = new StringBuilder(); 

    for (String str : vargs) 
     sb.append(str); 

    return sb.toString(); 
} 

Et l'utiliser comme:

String abcd = scat("a","b","c","d"); 

En C# On me dit son au sujet Identique à string.Concat();. Dans votre cas, il serait sage d'écrire une surcharge pour le scat, comme:

public static String scat(Collection<?> vargs) { 
    StringBuilder sb = new StringBuilder(); 

    for (Object str : vargs) 
     sb.append(str); 

    return sb.toString(); 
} 

Ensuite, vous pouvez l'appeler avec:

result = scat(myList) 

Answer 8

L'une des raisons pour lesquelles FindBugs devraient discuter en utilisant l'opérateur de concaténation (soit "+" ou "+ =") est localisabilité. Dans l'exemple que vous avez donné, il est pas évident, mais dans le cas du code ci-dessous il est:

String result = "Scanning found " + Integer.toString(numberOfViruses) + " viruses"; 

Si cela semble un peu familier, vous avez besoin de changer votre style de codage. Le problème, c'est que ça sonne bien en anglais, mais ça pourrait être un cauchemar pour les traducteurs. C'est juste parce que vous ne pouvez pas garantir que l'ordre de la phrase sera toujours le même après la traduction - certaines langues seront traduites en "1 bla bla", d'autres en "bla bla 3". Dans ce cas, vous devriez toujours utiliser MessageFormat.format() pour construire des phrases composées et utiliser un opérateur de concaténation est clairement un bug d'internationalisation.

BTW. Je mets un autre défaut i18n ici, pourriez-vous le repérer?

Answer 9

La durée de concaténation de deux chaînes est proportionnelle à la longueur des chaînes. S'il est utilisé dans une boucle, le temps de fonctionnement augmente toujours. Donc, si la concaténation est nécessaire dans une boucle, il vaut mieux utiliser StringBuilder comme Anthony suggéré.