[JAVA] [String type vs String Builder] Unterschied in der Verarbeitungsgeschwindigkeit in der String-Kombination

Einführung

Wenn Sie Strings in Java kombinieren, gibt es zwei Möglichkeiten, sie zu verbinden, entweder indem Sie sie mit "+ =" im String-Typ verbinden oder indem Sie sie mit "append ()" von StringBuilder verbinden.

Die Ergebnisse sind für beide gleich, es gibt jedoch einen Unterschied in der Verarbeitungsgeschwindigkeit.

Als ich es mit String gemacht habe

Zum Beispiel dieser Code

String stringResult = null;
    //String-Verkettung durch String-Objekt
    for (int i = 0; i < 10; i++) {
      String str = Integer.toString(i);
      stringResult += str;
    }

Da der String-Typ ein String-Objekt ist, bedeutet dies, dass eine String-Typ-Variable deklariert wird = ein String-Objekt erstellt wird.

Daher wird das String-Objekt zum Zeitpunkt von "stringResult + = str;" erstellt, was eine String-Verkettung ist.

Mit anderen Worten, String-Objekte werden für die Anzahl der Schleifen in der for-Anweisung erstellt.

Wenn Sie mit StringBuilder fertig sind

Zum Beispiel dieser Code

StringBuilder sb = new StringBuilder();
    //String Join von StringBuilder
    for (int j = 0; j < 10; j++) {
      sb.append(Integer.toString(j));
    }

Das Ergebnis ist das gleiche wie im String-Beispiel.

Append () erstellt jedoch kein String-Objekt. Fügen Sie es einfach bis zum Ende hinzu.

Die Verarbeitung ist schneller, da das String-Objekt nicht erstellt wird.

Wie unterschiedlich ist die Geschwindigkeit?

Ich habe den Unterschied in der Verarbeitungszeit zwischen String und StringBuilder mit dem folgenden Programm gemessen.

public class StringBuilderSample{
  public static void main(String[] args) {
    final int MAX_COUNT = 100;
    System.out.println("Anzahl der Joins:" + MAX_COUNT + "Wann");
    /*********************Für String-Typ*********************/
    String stringResult = null;

    //Zeitaufwand für die Verarbeitung mit String
    long sTime;

    //Startzeit
    long startTime = System.nanoTime();

    //Zeichenfolgenkombination nach Zeichenfolgentyp
    for (int i = 0; i < MAX_COUNT; i++) {
      String str = Integer.toString(i);
      stringResult += str;
    }

    //Endzeit
    long endTime = System.nanoTime();

    //Berechnen Sie die für die Verarbeitung benötigte Zeit
    sTime = endTime - startTime;

    System.out.println("Verarbeitungszeit in String:" + sTime + "Nano Sekunden");

    /*********************Für StringBuilder*********************/
    StringBuilder sb = new StringBuilder();

    //Zeit, die StringBuilder benötigt
    long sbTime;

    //Startzeit
    startTime = System.nanoTime();

    //String Join von StringBuilder
    for (int j = 0; j < MAX_COUNT; j++) {
      sb.append(Integer.toString(j));
    }

    //Endzeit
    endTime = System.nanoTime();

    //Berechnen Sie die für die Verarbeitung benötigte Zeit
    sbTime = endTime - startTime;

    System.out.println("Verarbeitungszeit in StringBuilder:" + sbTime + "Nano Sekunden");
    System.out.println("StringBuilder ist besser" + (sTime - sbTime) + "Nano Sekunden schneller");
  }
}

Es ist ein Programm, das die Verarbeitungsgeschwindigkeit anzeigt, wenn die Verkettung von Zeichenfolgen so oft wie "MAX_COUNT" ausgeführt wird.

Im Folgenden werden wir den Unterschied in der Verarbeitungszeit untersuchen und gleichzeitig den Wert von "MAX_COUNT" auf 100, 1000, 10.000, 100.000 erhöhen.

Nanosekunden sind übrigens 10 ^ (-9) Sekunden (= 0,000000001 Sekunden).

Bei 100-maliger Ausführung

Bei 1000-maliger Ausführung

Bei 10.000-maliger Ausführung

Etwa 0,57 Sekunden schneller

Bei 100.000-maliger Ausführung

Etwa 27 Sekunden schneller

StringBuilder war schneller!

Es stört mich nicht so sehr, weil der Unterschied höchstens 1000-mal in Mikrosekunden (10 ^ (-6)) beträgt.

Ab etwa 10.000 Mal wird der Unterschied in der Verarbeitungszeit ängstlich.

Nun, es ist wahr, dass StringBuilder schneller ist, egal wie oft Sie es ausführen. Wenn Sie also keinen bestimmten Grund haben, sollten Sie StringBuilder zum Zusammenführen von Strings verwenden.

schließlich

Eigentlich ist dieser Artikel ein Nachdruck aus dem Blog. Ich poste auch über andere Dinge in meinem Blog.

** Kritzeleien des Systemingenieurs-Hatena-Blogs **

2018 07/21 Nachtrag: Ich habe eine Fortsetzung geschrieben → [java] Verwenden Sie nicht "+" im Anhang!