"Lorsque vous joignez des chaînes en Java, vous devez utiliser StringBuilder plutôt que d'utiliser l'opérateur + sur String." "Les changements de performances ne le sont pas lorsqu'il y a peu de jointures de chaînes, mais il est préférable d'utiliser StringBuilder lorsqu'il y en a beaucoup." J'entends parfois ça.
StringBuilder est plus efficace que toute autre chose lorsque vous effectuez en fait un grand nombre de jointures de chaînes à plusieurs reprises, mais là-bas et [ici](https :: //qiita.com/ota-meshi/items/40d5dcb0e99574a8a368#stringbuilder%E3%81%A8stringbuffer) a déjà obtenu le résultat de la vérification, je vais donc le laisser.
Cependant, lors du codage, par exemple, lorsque vous souhaitez afficher une chaîne de caractères entourée de [chaîne de caractères], il existe de nombreux cas où la combinaison de chaînes de caractères n'est exécutée que quelques fois. Dans ce cas, il est inutile de créer une nouvelle instance de StringBuilder, d'y mettre une chaîne de caractères, de combiner les chaînes de caractères seulement quelques fois, puis de la renvoyer au type String. ..
Combien de fois devrions-nous combiner des chaînes avant de passer à StringBuilder? Même si je l'ai cherché sur Google, il n'est pas sorti facilement, alors je l'ai vérifié moi-même.
La méthode de mesure est
Lors de l'utilisation de l'opérateur +: déclarer une chaîne de caractères → combiner les chaînes de caractères appropriées n fois
PlusTest.java
public static void main(String[] args) {
for(int j = 0; j < LOOP; j++){
String str = "s";
plus(str, BUILD_NUM);
}
}
private static String plus(String str, int n) {
for (int i = 0; i < n; i++) {
str += "p";
}
return str;
}
Lors de l'utilisation de StringBuilder: Déclarez une chaîne → Créez une instance StringBuilder → Combinez les chaînes appropriées n fois
StringBuilderTest.java
public static void main(String[] args) {
for(int j = 0; j < LOOP; j++){
String str = "s";
sb(str, BUILD_NUM);
}
}
private static String sb(String str, int n) {
StringBuilder sb = new StringBuilder().append(str);
for (int i = 0; i < n; i++) {
sb.append("b");
}
return sb.toString();
}
Cette série d'étapes est répétée 10 millions de fois et le temps pris est mesuré. À propos, la mesure est répétée environ 10 fois pour obtenir la valeur médiane.
0 jointure
Une fois que
Deux fois
3 fois
Le résultat était décevant. À propos, le temps de mesure de StringBuilder variait considérablement, et parfois 1 temps était plus court que 0 fois de jointure (juste déclaré). Si le nombre de connexions est augmenté plusieurs fois, il semble qu'il ne fluctuera que dans la plage d'erreur. Dans tous les cas, c'est généralement plus rapide que d'utiliser l'opérateur +.
Lorsque j'essaye de combiner des chaînes avec l'opérateur +, il semble que le compilateur crée une instance StringBuilder et la combine (Reference). Ainsi, "lors de l'utilisation de l'opérateur +: déclarer une chaîne de caractères-> combiner les chaînes de caractères appropriées n fois" est correctement "déclarer une chaîne de caractères-> (créer une instance StringBuilder-> combiner) * n". Sera. Cependant, même s'il n'est combiné qu'une seule fois, cela prend deux fois plus de temps que le résultat de la mesure ... Créez-vous une instance de chaîne en vain?
Si vous ne voulez combiner qu'une seule fois, le compilateur le fera pour vous, donc ce devrait être l'un ou l'autre (plutôt, il est préférable d'utiliser l'opérateur + car le code est désordonné), mais si vous êtes nerveux, il est préférable de déclarer StringBuilder et de l'utiliser. Je me sens comme. Si vous tournez plus d'une fois dans une boucle, il est préférable d'utiliser StringBuilder pour réduire les déclarations StringBuilder inutiles.
[^ 1]: C'est un nombre peu fiable parce que je n'ai eu que 0 ms ou 16 ms, mais je l'ignore car je mesure simplement le temps du code qui gaspille simplement l'instruction for en premier lieu.
Recommended Posts