[JAVA] Test de comparaison de vitesse pour String, StringBuilder, StringBuffer

-Un objet String est créé chaque fois qu'une chaîne est concaténée à l'aide de la classe String.

-Il est dit que les classes StringBuilder et StringBuffer doivent être utilisées car il s'agit d'une surcharge.

・ Je n'utilise pas ces classes en disant: "Ce n'est pas un gros problème." Bien sûr, vous devriez l'utiliser si vous en avez beaucoup de temps, mais (pour moi) c'est rare.

-Lors de l'utilisation de ces classes, c'est un petit problème que le code source devient difficile à voir.

・ J'ai mesuré à quel point c'était différent.

-En gros, cela prend plus de 10 fois lors de l'utilisation directe de String. -Cependant, le temps absolu n'est pas grand en premier lieu, donc si le nombre de fois est petit, je pense que l'opération directe String est suffisante.

-Veuillez l'utiliser pour le jugement lors de l'utilisation de StringBuffer (StringBuilder).

-Quand il atteint 1 million de fois, StringBuffer est plus rapide que StringBuilder. La raison est inconnue (pour moi).

・ Ici, le résultat est affiché une fois, mais la tendance est la même quel que soit le nombre de fois.

-Différence entre StringBuffer et StringBuilder. Le premier est thread-safe et le second ne l'est pas. Ce dernier est nouveau.

・ La raison pour laquelle je ne l'ai pas rendu sûr pour les threads est qu'il est rarement utilisé dans les threads, et je ne veux pas ralentir à cause de cela (Imaginez).

-Si vous souhaitez utiliser StringBuilder dans un thread, vous devez le contrôler vous-même.

Tips0016.java

package jp.avaj.lib.algo;

import java.util.Date;

import jp.avaj.lib.test.L;

class Tips0016 {
  private static int CNT0;
  private static final int CNT1 = 100; //
  public static void main(String[] args) {
    L.p("====10000 fois");
    CNT0 = 10000;
    execString();
    execStringBuilder();
    execStringBuffer();

    L.p("====100 000 fois");
    CNT0 = 100000;
    execString();
    execStringBuilder();
    execStringBuffer();

    L.p("====Des millions de fois");
    CNT0 = 1000000;
    execString();
    execStringBuilder();
    execStringBuffer();

  }

  private static void execString() {
    long start = (new Date()).getTime();
    for (int i=0; i<CNT0; i++) {
      String s = "";
      for (int j=0; j<CNT1; j++) {
        s += "aaa";
      }
    }
    long end = (new Date()).getTime();
    diff("String",start,end);
  }
  private static void execStringBuilder() {
    long start = (new Date()).getTime();
    for (int i=0; i<CNT0; i++) {
      StringBuilder sb = new StringBuilder();
      for (int j=0; j<CNT1; j++) {
        sb.append("aaa");
      }
    }
    long end = (new Date()).getTime();
    diff("StringBuilder",start,end);
  }
  private static void execStringBuffer() {
    long start = (new Date()).getTime();
    for (int i=0; i<CNT0; i++) {
      StringBuffer sb = new StringBuffer();
      for (int j=0; j<CNT1; j++) {
        sb.append("aaa");
      }
    }
    long end = (new Date()).getTime();
    diff("StringBuffer",start,end);
  }

  private static void diff(String desc,long start,long end) {
    L.p(desc+"="+(end-start));
  }
}

Le résultat de l'exécution est le suivant.

Tips0016.txt

====10000 fois
String=230
StringBuilder=31
StringBuffer=52
====100 000 fois
String=1383
StringBuilder=149
StringBuffer=352
====Des millions de fois
String=12336
StringBuilder=1433
StringBuffer=1388