[JAVA] [Type de chaîne vs Générateur de chaînes] Différence de vitesse de traitement dans la combinaison de chaînes

introduction

Lors de la combinaison de chaînes en Java, il y a deux façons de les connecter, soit en les connectant avec + = dans le type String, soit en les connectant avec ʻappend () `de StringBuilder.

Les résultats sont les mêmes pour les deux, mais il existe une différence de vitesse de traitement.

Quand je l'ai fait avec String

Par exemple, ce code

String stringResult = null;
    //Concaténation de chaînes par objet String
    for (int i = 0; i < 10; i++) {
      String str = Integer.toString(i);
      stringResult += str;
    }

Puisque le type String est un objet String, cela signifie qu'une variable de type String est déclarée = un objet String est créé.

Par conséquent, l'objet String est créé au moment de stringResult + = str; qui est une concaténation de chaînes.

En d'autres termes, les objets String sont créés pour le nombre de boucles dans l'instruction for.

Une fois terminé avec StringBuilder

Par exemple, ce code

StringBuilder sb = new StringBuilder();
    //Jointure de chaîne par StringBuilder
    for (int j = 0; j < 10; j++) {
      sb.append(Integer.toString(j));
    }

Le résultat est le même que celui de l'exemple String.

Cependant, ʻappend () `ne crée pas d'objet String. Ajoutez-le simplement à la fin.

Le traitement est plus rapide car l'objet String n'est pas créé.

Quelle est la différence entre la vitesse?

J'ai mesuré la différence de temps de traitement entre String et StringBuilder avec le programme suivant.

public class StringBuilderSample{
  public static void main(String[] args) {
    final int MAX_COUNT = 100;
    System.out.println("Nombre de jointures:" + MAX_COUNT + "Quand");
    /*********************Pour le type String*********************/
    String stringResult = null;

    //Temps de traitement avec String
    long sTime;

    //Heure de début
    long startTime = System.nanoTime();

    //Combinaison de chaînes par type de chaîne
    for (int i = 0; i < MAX_COUNT; i++) {
      String str = Integer.toString(i);
      stringResult += str;
    }

    //heure de fin
    long endTime = System.nanoTime();

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

    System.out.println("Temps de traitement en chaîne:" + sTime + "Nano secondes");

    /*********************Pour StringBuilder*********************/
    StringBuilder sb = new StringBuilder();

    //Temps pris par StringBuilder
    long sbTime;

    //Heure de début
    startTime = System.nanoTime();

    //Jointure de chaîne par StringBuilder
    for (int j = 0; j < MAX_COUNT; j++) {
      sb.append(Integer.toString(j));
    }

    //heure de fin
    endTime = System.nanoTime();

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

    System.out.println("Temps de traitement dans StringBuilder:" + sbTime + "Nano secondes");
    System.out.println("StringBuilder est meilleur" + (sTime - sbTime) + "Nano secondes plus rapide");
  }
}

C'est un programme qui affiche la vitesse de traitement lorsque la concaténation de chaînes est effectuée autant de fois que «MAX_COUNT».

Ci-dessous, nous examinerons la différence de temps de traitement tout en augmentant la valeur de MAX_COUNT à 100, 1000, 10000, 100000.

À propos, les nanosecondes correspondent à 10 ^ (-9) secondes (= 0,00000000001 secondes).

Lorsqu'il est exécuté 100 fois

Lorsqu'il est exécuté 1000 fois

Lorsqu'elle est exécutée 10000 fois

Environ 0.57 seconde plus rapide

Lorsqu'il est exécuté 100 000 fois

Environ 27 secondes plus rapide

StringBuilder était plus rapide!

Cela ne me dérange pas tellement parce que la différence est jusqu'à environ 1000 fois en microsecondes (10 ^ (-6)) au plus.

À partir d'environ 10 000 fois, la différence de temps de traitement devient angoissante.

Eh bien, il est vrai que StringBuilder est plus rapide quel que soit le nombre de fois que vous l'exécutez, donc à moins que vous n'ayez une raison spécifique, vous devez utiliser StringBuilder pour la fusion de chaînes.

à la fin

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

** Gribouillis des ingénieurs système-blog Hatena **

2018 07/21 Addendum: J'ai écrit une suite → [java] Ne pas utiliser "+" dans l'append!