[Java] N'utilisez pas "+" dans append!

Ceci est une suite de Dernier message.

La dernière fois, j'ai écrit qu'il est préférable d'utiliser la méthode append de StringBuilder lors de la concaténation de chaînes en Java.

Cependant, je vois parfois du code qui utilise mal l'ajout.

Mauvais cas d'utilisation d'ajout

Par exemple, ce code

StringBuilder sb = new StringBuilder();
String val = "hoge";
sb.append("[" + val + "]")

Les jointures de chaîne utilisant «+» ralentiront le processus car elles créeront un objet String à chaque fois.

Dans cet exemple, l'objet String a été créé dans la partie " ["+ val +"] ", donc la vitesse de traitement finira par ralentir.

Exemple d'amélioration

Faisons cela

StringBuilder sb = new StringBuilder();
String val = "hoge";
sb.append("[").append(val).append("]");

Au lieu d'utiliser «+» pour vous connecter, utilisez append plusieurs fois pour vous connecter.

Alors, dans quelle mesure la vitesse de traitement change-t-elle avant et après l'amélioration?

Vérifiez la différence de vitesse de traitement

J'ai comparé la vitesse de traitement avec le code ci-dessous.

public class StringBuilderTest{
  public static void main(String[] args) {
    final int MAX_COUNT = 100;
    System.out.println("Nombre de jointures:" + MAX_COUNT + "Quand");

    StringBuilder sb1 = new StringBuilder();
    StringBuilder sb2 = new StringBuilder();

    long resultTime1;
    long resultTime2;
    long startTime;
    long endTime;

    /*********************Avant amélioration: ajouter()Lors de l'exécution d'une combinaison de cordes dans*********************/
    //Heure de début
    startTime = System.nanoTime();

    for (int i = 0; i < MAX_COUNT; i++) {
      sb2.append(Integer.toString(i) + "\n");
    }
    //heure de fin
    endTime = System.nanoTime();

    //Calculez le temps de traitement
    resultTime1 = endTime - startTime;

    /*********************Après amélioration: ajouter()Lors de l'utilisation deux fois*********************/
    //Heure de début
    startTime = System.nanoTime();

    //Jointure de chaîne par StringBuilder
    for (int i = 0; i < MAX_COUNT; i++) {
      sb1.append(Integer.toString(i)).append("\n");
    }
    //heure de fin
    endTime = System.nanoTime();

    //Temps pris
    resultTime2 = endTime - startTime;

    System.out.println("① append()Temps de traitement lors de la combinaison dans:" + resultTime1 + "Nano secondes");
    System.out.println("② append()Temps de traitement lors de l'utilisation deux fois:" + resultTime2 + "Nano secondes");
    System.out.println("② c'est mieux" + (resultTime1 - resultTime2) + "Nano secondes plus rapide");
  }
}

C'est un programme qui compare la différence de vitesse de traitement lorsque la combinaison de chaînes de caractères est effectuée 100 fois.

Le résultat est ci-dessous.

Il est plus rapide d'utiliser ʻappend` deux fois.

à la fin

En fait, cet article est une réimpression du blog. Je publie également d'autres choses sur mon blog.

** Mémorandum des griffonnages SE de 1ère année - Blog Hatena **