Ist es besser, String.format über String-Verkettung in Java zu verwenden?

Gibt es einen wahrnehmbaren Unterschied zwischen der Verwendung String.formatund der Verkettung von Zeichenfolgen in Java?

Ich neige dazu zu verwenden String.format, werde aber gelegentlich ausrutschen und eine Verkettung verwenden. Ich fragte mich, ob einer besser war als der andere.

So wie ich es sehe, haben String.formatSie mehr Möglichkeiten, die Zeichenfolge zu "formatieren". und Verkettung bedeutet, dass Sie sich keine Sorgen machen müssen, dass Sie versehentlich zusätzliche% s eingeben oder eine verpassen.

String.format ist auch kürzer.

Welches besser lesbar ist, hängt davon ab, wie Ihr Kopf funktioniert.

Ich würde vorschlagen, dass es besser ist, zu verwenden String.format(). Der Hauptgrund ist, dass String.format()die Lokalisierung mit Text aus Ressourcendateien einfacher ist, während die Verkettung nicht lokalisiert werden kann, ohne eine neue ausführbare Datei mit unterschiedlichem Code für jede Sprache zu erstellen.

Wenn Sie planen, dass Ihre App lokalisierbar ist, sollten Sie sich auch angewöhnen, Argumentpositionen für Ihre Format-Token anzugeben:

"Hello %1$s the time is %2$t"

Dies kann dann lokalisiert werden und die Namen- und Zeit-Token können ausgetauscht werden, ohne dass eine Neukompilierung der ausführbaren Datei erforderlich ist, um die unterschiedliche Reihenfolge zu berücksichtigen. Mit Argumentpositionen können Sie dasselbe Argument auch wiederverwenden, ohne es zweimal an die Funktion zu übergeben:

String.format("Hello %1$s, your name is %1$s and the time is %2$t", name, time)

Über die Leistung:

public static void main(String[] args) throws Exception {      
  long start = System.currentTimeMillis();
  for(int i = 0; i < 1000000; i++){
    String s = "Hi " + i + "; Hi to you " + i*2;
  }
  long end = System.currentTimeMillis();
  System.out.println("Concatenation = " + ((end - start)) + " millisecond") ;

  start = System.currentTimeMillis();
  for(int i = 0; i < 1000000; i++){
    String s = String.format("Hi %s; Hi to you %s",i, + i*2);
  }
  end = System.currentTimeMillis();
  System.out.println("Format = " + ((end - start)) + " millisecond");
}

Die Timing-Ergebnisse sind wie folgt:

• Verkettung = 265 Millisekunden
• Format = 4141 Millisekunden

Daher ist die Verkettung viel schneller als String.format.

Da es Diskussionen über die Leistung gibt, dachte ich, ich würde sie in einem Vergleich mit StringBuilder hinzufügen. Es ist in der Tat schneller als das concat und natürlich die Option String.format.

Um dies zu einer Art Vergleich von Äpfeln zu Äpfeln zu machen, instanziiere ich einen neuen StringBuilder in der Schleife und nicht außerhalb (dies ist tatsächlich schneller als nur eine Instanziierung, was höchstwahrscheinlich auf den Aufwand zurückzuführen ist, den Speicherplatz für das Anhängen der Schleife am Ende von neu zuzuweisen ein Baumeister).

    String formatString = "Hi %s; Hi to you %s";

    long start = System.currentTimeMillis();
    for (int i = 0; i < 1000000; i++) {
        String s = String.format(formatString, i, +i * 2);
    }

    long end = System.currentTimeMillis();
    log.info("Format = " + ((end - start)) + " millisecond");

    start = System.currentTimeMillis();

    for (int i = 0; i < 1000000; i++) {
        String s = "Hi " + i + "; Hi to you " + i * 2;
    }

    end = System.currentTimeMillis();

    log.info("Concatenation = " + ((end - start)) + " millisecond");

    start = System.currentTimeMillis();

    for (int i = 0; i < 1000000; i++) {
        StringBuilder bldString = new StringBuilder("Hi ");
        bldString.append(i).append("; Hi to you ").append(i * 2);
    }

    end = System.currentTimeMillis();

    log.info("String Builder = " + ((end - start)) + " millisecond");

• 2012-01-11 16: 30: 46,058 INFO [TestMain] - Format = 1416 Millisekunden
• 2012-01-11 16: 30: 46,190 INFO [TestMain] - Verkettung = 134 Millisekunden
• 2012-01-11 16: 30: 46,313 INFO [TestMain] - String Builder = 117 Millisekunden

Ein Problem dabei .formatist, dass Sie die Sicherheit des statischen Typs verlieren. Sie können zu wenige Argumente für Ihr Format haben, und Sie können die falschen Typen für die Formatspezifizierer haben - beides führt zur IllegalFormatException Laufzeit , sodass Sie möglicherweise Protokollierungscode erhalten, der die Produktion unterbricht.

Im Gegensatz dazu können die Argumente +vom Compiler getestet werden.

Die Sicherheitsgeschichte vonprintf(nach dem die formatFunktion modelliert ist) ist lang und erschreckend.

Welches besser lesbar ist, hängt davon ab, wie Ihr Kopf funktioniert.

Sie haben Ihre Antwort genau dort.

Es ist eine Frage des persönlichen Geschmacks.

Die Verkettung von Strings ist vermutlich etwas schneller, aber das sollte vernachlässigbar sein.

Hier ist ein Test mit mehreren Stichprobengrößen in Millisekunden.

public class Time {

public static String sysFile = "/sys/class/camera/rear/rear_flash";
public static String cmdString = "echo %s > " + sysFile;

public static void main(String[] args) {

  int i = 1;
  for(int run=1; run <= 12; run++){
      for(int test =1; test <= 2 ; test++){
        System.out.println(
                String.format("\nTEST: %s, RUN: %s, Iterations: %s",run,test,i));
        test(run, i);
      }
      System.out.println("\n____________________________");
      i = i*3;
  }
}

public static void test(int run, int iterations){

      long start = System.nanoTime();
      for( int i=0;i<iterations; i++){
          String s = "echo " + i + " > "+ sysFile;
      }
      long t = System.nanoTime() - start;   
      String r = String.format("  %-13s =%10d %s", "Concatenation",t,"nanosecond");
      System.out.println(r) ;


     start = System.nanoTime();       
     for( int i=0;i<iterations; i++){
         String s =  String.format(cmdString, i);
     }
     t = System.nanoTime() - start; 
     r = String.format("  %-13s =%10d %s", "Format",t,"nanosecond");
     System.out.println(r);

      start = System.nanoTime();          
      for( int i=0;i<iterations; i++){
          StringBuilder b = new StringBuilder("echo ");
          b.append(i).append(" > ").append(sysFile);
          String s = b.toString();
      }
     t = System.nanoTime() - start; 
     r = String.format("  %-13s =%10d %s", "StringBuilder",t,"nanosecond");
     System.out.println(r);
}

}}

TEST: 1, RUN: 1, Iterations: 1
  Concatenation =     14911 nanosecond
  Format        =     45026 nanosecond
  StringBuilder =      3509 nanosecond

TEST: 1, RUN: 2, Iterations: 1
  Concatenation =      3509 nanosecond
  Format        =     38594 nanosecond
  StringBuilder =      3509 nanosecond

____________________________

TEST: 2, RUN: 1, Iterations: 3
  Concatenation =      8479 nanosecond
  Format        =     94438 nanosecond
  StringBuilder =      5263 nanosecond

TEST: 2, RUN: 2, Iterations: 3
  Concatenation =      4970 nanosecond
  Format        =     92976 nanosecond
  StringBuilder =      5848 nanosecond

____________________________

TEST: 3, RUN: 1, Iterations: 9
  Concatenation =     11403 nanosecond
  Format        =    287115 nanosecond
  StringBuilder =     14326 nanosecond

TEST: 3, RUN: 2, Iterations: 9
  Concatenation =     12280 nanosecond
  Format        =    209051 nanosecond
  StringBuilder =     11818 nanosecond

____________________________

TEST: 5, RUN: 1, Iterations: 81
  Concatenation =     54383 nanosecond
  Format        =   1503113 nanosecond
  StringBuilder =     40056 nanosecond

TEST: 5, RUN: 2, Iterations: 81
  Concatenation =     44149 nanosecond
  Format        =   1264241 nanosecond
  StringBuilder =     34208 nanosecond

____________________________

TEST: 6, RUN: 1, Iterations: 243
  Concatenation =     76018 nanosecond
  Format        =   3210891 nanosecond
  StringBuilder =     76603 nanosecond

TEST: 6, RUN: 2, Iterations: 243
  Concatenation =     91222 nanosecond
  Format        =   2716773 nanosecond
  StringBuilder =     73972 nanosecond

____________________________

TEST: 8, RUN: 1, Iterations: 2187
  Concatenation =    527450 nanosecond
  Format        =  10291108 nanosecond
  StringBuilder =    885027 nanosecond

TEST: 8, RUN: 2, Iterations: 2187
  Concatenation =    526865 nanosecond
  Format        =   6294307 nanosecond
  StringBuilder =    591773 nanosecond

____________________________

TEST: 10, RUN: 1, Iterations: 19683
  Concatenation =   4592961 nanosecond
  Format        =  60114307 nanosecond
  StringBuilder =   2129387 nanosecond

TEST: 10, RUN: 2, Iterations: 19683
  Concatenation =   1850166 nanosecond
  Format        =  35940524 nanosecond
  StringBuilder =   1885544 nanosecond

  ____________________________

TEST: 12, RUN: 1, Iterations: 177147
  Concatenation =  26847286 nanosecond
  Format        = 126332877 nanosecond
  StringBuilder =  17578914 nanosecond

TEST: 12, RUN: 2, Iterations: 177147
  Concatenation =  24405056 nanosecond
  Format        = 129707207 nanosecond
  StringBuilder =  12253840 nanosecond

Hier ist der gleiche Test wie oben mit der Änderung des Aufrufs der toString () -Methode im StringBuilder . Die folgenden Ergebnisse zeigen, dass der StringBuilder-Ansatz nur etwas langsamer ist als die String-Verkettung mit dem Operator + .

Datei: StringTest.java

class StringTest {

  public static void main(String[] args) {

    String formatString = "Hi %s; Hi to you %s";

    long start = System.currentTimeMillis();
    for (int i = 0; i < 1000000; i++) {
        String s = String.format(formatString, i, +i * 2);
    }

    long end = System.currentTimeMillis();
    System.out.println("Format = " + ((end - start)) + " millisecond");

    start = System.currentTimeMillis();

    for (int i = 0; i < 1000000; i++) {
        String s = "Hi " + i + "; Hi to you " + i * 2;
    }

    end = System.currentTimeMillis();

    System.out.println("Concatenation = " + ((end - start)) + " millisecond");

    start = System.currentTimeMillis();

    for (int i = 0; i < 1000000; i++) {
        StringBuilder bldString = new StringBuilder("Hi ");
        bldString.append(i).append("Hi to you ").append(i * 2).toString();
    }

    end = System.currentTimeMillis();

    System.out.println("String Builder = " + ((end - start)) + " millisecond");

  }
}

Shell-Befehle: (5-mal kompilieren und StringTest ausführen)

> javac StringTest.java
> sh -c "for i in \$(seq 1 5); do echo \"Run \${i}\"; java StringTest; done"

Ergebnisse :

Run 1
Format = 1290 millisecond
Concatenation = 115 millisecond
String Builder = 130 millisecond

Run 2
Format = 1265 millisecond
Concatenation = 114 millisecond
String Builder = 126 millisecond

Run 3
Format = 1303 millisecond
Concatenation = 114 millisecond
String Builder = 127 millisecond

Run 4
Format = 1297 millisecond
Concatenation = 114 millisecond
String Builder = 127 millisecond

Run 5
Format = 1270 millisecond
Concatenation = 114 millisecond
String Builder = 126 millisecond

String.format()ist mehr als nur das Verketten von Zeichenfolgen. Beispielsweise können Sie mit Nummern in einem bestimmten Gebietsschema anzeigen String.format().

Wenn Sie sich jedoch nicht für die Lokalisierung interessieren, gibt es keinen funktionalen Unterschied. Vielleicht ist der eine schneller als der andere, aber in den meisten Fällen wird er vernachlässigbar sein.

Im Allgemeinen sollte die Verkettung von Zeichenfolgen der Verkettung vorgezogen werden String.format. Letzteres hat zwei Hauptnachteile:

1. Die zu erstellende Zeichenfolge wird nicht lokal codiert.
2. Der Erstellungsprozess ist in einer Zeichenfolge codiert.

Mit Punkt 1 meine ich, dass es nicht möglich ist zu verstehen, was ein String.format()Anruf in einem einzigen sequentiellen Durchgang tut. Man ist gezwungen, zwischen der Formatzeichenfolge und den Argumenten hin und her zu gehen, während man die Position der Argumente zählt. Bei kurzen Verkettungen ist dies kein großes Problem. In diesen Fällen ist die Verkettung von Zeichenfolgen jedoch weniger ausführlich.

Mit Punkt 2 meine ich, dass der wichtige Teil des Erstellungsprozesses in der Formatzeichenfolge (unter Verwendung einer DSL) codiert ist . Die Verwendung von Zeichenfolgen zur Darstellung von Code hat viele Nachteile. Es ist nicht von Natur aus typsicher und erschwert das Hervorheben der Syntax, die Codeanalyse, die Optimierung usw.

Natürlich können bei der Verwendung von Tools oder Frameworks außerhalb der Java-Sprache neue Faktoren ins Spiel kommen.

Ich habe keine spezifischen Benchmarks durchgeführt, aber ich würde denken, dass die Verkettung schneller sein kann. String.format () erstellt einen neuen Formatierer, der wiederum einen neuen StringBuilder erstellt (mit einer Größe von nur 16 Zeichen). Das ist ein ziemlicher Aufwand, insbesondere wenn Sie eine längere Zeichenfolge formatieren und die Größe von StringBuilder ständig geändert werden muss.

Verkettung ist jedoch weniger nützlich und schwerer zu lesen. Wie immer lohnt es sich, einen Benchmark für Ihren Code durchzuführen, um festzustellen, welcher besser ist. Die Unterschiede können in der Server-App vernachlässigbar sein, nachdem Ihre Ressourcenpakete, Gebietsschemas usw. in den Speicher geladen wurden und der Code JITted ist.

Als bewährte Methode ist es möglicherweise eine gute Idee, einen eigenen Formatierer mit einem StringBuilder (anhängbar) und einem Gebietsschema in der richtigen Größe zu erstellen und diesen zu verwenden, wenn Sie viel zu formatieren haben.

Es könnte einen wahrnehmbaren Unterschied geben.

String.format ist ziemlich komplex und verwendet einen regulären Ausdruck darunter. Machen Sie es sich also nicht zur Gewohnheit, ihn überall zu verwenden, sondern nur dort, wo Sie ihn brauchen.

StringBuilder wäre eine Größenordnung schneller (wie hier schon jemand betont hat).

Ich denke, wir können mitmachen, MessageFormat.formatda es sowohl in Bezug auf die Lesbarkeit als auch in Bezug auf die Leistung gut sein sollte.

Ich habe dasselbe Programm verwendet, das Icaro in seiner obigen Antwort verwendet hat, und es mit angehängtem Code MessageFormatzur Erläuterung der Leistungszahlen erweitert.

  public static void main(String[] args) {
    long start = System.currentTimeMillis();
    for (int i = 0; i < 1000000; i++) {
      String s = "Hi " + i + "; Hi to you " + i * 2;
    }
    long end = System.currentTimeMillis();
    System.out.println("Concatenation = " + ((end - start)) + " millisecond");

    start = System.currentTimeMillis();
    for (int i = 0; i < 1000000; i++) {
      String s = String.format("Hi %s; Hi to you %s", i, +i * 2);
    }
    end = System.currentTimeMillis();
    System.out.println("Format = " + ((end - start)) + " millisecond");

    start = System.currentTimeMillis();
    for (int i = 0; i < 1000000; i++) {
      String s = MessageFormat.format("Hi %s; Hi to you %s", i, +i * 2);
    }
    end = System.currentTimeMillis();
    System.out.println("MessageFormat = " + ((end - start)) + " millisecond");
  }

Verkettung = 69 Millisekunden

Format = 1435 Millisekunden

MessageFormat = 200 Millisekunden

AKTUALISIERUNG:

Gemäß SonarLint Report sollten Zeichenfolgen im Printf-Format korrekt verwendet werden (Tintenfisch: S3457).

Da printf-styleFormatzeichenfolgen zur Laufzeit interpretiert und nicht vom Compiler überprüft werden, können sie Fehler enthalten, die dazu führen, dass falsche Zeichenfolgen erstellt werden. Diese Regel überprüft statisch die Korrelation von printf-styleFormatstrings , um ihre Argumente , wenn das Format (...) Methoden der Aufruf java.util.Formatter, java.lang.String, java.io.PrintStream, MessageFormat, und java.io.PrintWriterKlassen und die printf(...)Methoden der java.io.PrintStreamoder java.io.PrintWriterKlassen.

Ich ersetze den printf-Stil durch die geschweiften Klammern und habe wie unten einige interessante Ergebnisse erhalten.

Verkettung = 69 Millisekunden
Format = 1107 Millisekunden
Format: geschweifte Klammern = 416 Millisekunden
MessageFormat = 215 Millisekunden
MessageFormat: geschweifte Klammern = 2517 Millisekunden

Mein Fazit:
Wie ich oben hervorgehoben habe, sollte die Verwendung von String.format mit geschweiften Klammern eine gute Wahl sein, um die Vorteile einer guten Lesbarkeit und Leistung zu erzielen.

Sie können String Concatenation und String.Format mit dem obigen Programm nicht vergleichen.

Sie können dies auch versuchen, indem Sie die Position der Verwendung Ihres String.Format und der Verkettung in Ihrem Codeblock wie unten vertauschen

public static void main(String[] args) throws Exception {      
  long start = System.currentTimeMillis();

  for( int i=0;i<1000000; i++){
    String s = String.format( "Hi %s; Hi to you %s",i, + i*2);
  }

  long end = System.currentTimeMillis();
  System.out.println("Format = " + ((end - start)) + " millisecond");
  start = System.currentTimeMillis();

  for( int i=0;i<1000000; i++){
    String s = "Hi " + i + "; Hi to you " + i*2;
  }

  end = System.currentTimeMillis();
  System.out.println("Concatenation = " + ((end - start)) + " millisecond") ;
}

Sie werden überrascht sein, dass Format hier schneller funktioniert. Dies liegt daran, dass die ursprünglich erstellten Objekte möglicherweise nicht freigegeben werden und ein Problem mit der Speicherzuweisung und damit der Leistung auftreten kann.

Es dauert ein wenig, bis man sich an String.Format gewöhnt hat, aber es lohnt sich in den meisten Fällen. In der Welt von NRA (wiederholen Sie niemals etwas) ist es äußerst nützlich, Ihre tokenisierten Nachrichten (Protokollierung oder Benutzer) in einer konstanten Bibliothek zu speichern (ich bevorzuge eine statische Klasse) und sie bei Bedarf mit String.Format aufzurufen, unabhängig davon, ob Sie lokalisieren oder nicht. Der Versuch, eine solche Bibliothek mit einer Verkettungsmethode zu verwenden, ist mit jedem Ansatz, der eine Verkettung erfordert, schwieriger zu lesen, Fehler zu beheben, Korrektur zu lesen und zu verwalten. Ersatz ist eine Option, aber ich bezweifle, dass es performant ist. Nach Jahren der Verwendung ist mein größtes Problem mit String.Format, dass die Länge des Aufrufs unpraktisch lang ist, wenn ich ihn an eine andere Funktion (wie Msg) übergebe. Mit einer benutzerdefinierten Funktion, die als Alias ​​dient, ist dies jedoch leicht zu umgehen .