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

273

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.

Omar Kooheji
quelle
Ich denke, wir können mit MessageFormat.format gehen. Weitere Informationen finden Sie in der Antwort stackoverflow.com/a/56377112/1491414 .
Ganesa Vijayakumar

Antworten:

242

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)
workmad3
quelle
1
Können Sie mich auf eine Dokumentation verweisen, in der erläutert wird, wie mit Argumentpositionen / -reihenfolge in Java gearbeitet wird (dh wie Argumente anhand ihrer Position referenziert werden)? Vielen Dank.
Markvgti
13
Besser spät als nie, zufällige Java-Version: docs.oracle.com/javase/1.5.0/docs/api/java/util/…
Aksel
174

Ü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.

Icaro
quelle
15
Sie sind alle schlechte Praxis. Verwenden Sie StringBuilder.
Amir Raminfar
8
StringBuilder ist hier nicht verfügbar (bei der OP-Frage ging es um den Vergleich von String.format über String-Verkettung), aber haben Sie Leistungsdaten zu String Builder?
Icaro
108
@AmirRaminar: Der Compiler konvertiert "+" automatisch in Aufrufe von StringBuilder.
Martin Schröder
40
@ MartinSchröder: Wenn Sie ausführen, werden javap -c StringTest.classSie feststellen, dass der Compiler "+" nur dann automatisch in StringBuilder konvertiert, wenn Sie sich nicht in einer Schleife befinden. Wenn die Verkettung ausschließlich in einer einzelnen Zeile erfolgt, entspricht dies der Verwendung von '+'. Wenn Sie jedoch myString += "morechars";oder myString += anotherString;in mehreren Zeilen verwenden, werden Sie feststellen, dass möglicherweise mehr als ein StringBuilder erstellt wird. Daher ist die Verwendung von "+" nicht immer so effizient als StringBuilder.
ccpizza
7
@Joffrey: Ich meinte, dass for-Schleifen +nicht konvertiert werden, StringBuilder.append()sondern new StringBuilder()bei jeder Iteration ein passiert.
ccpizza
39

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
TechTrip
quelle
21
Der StringBuilder-Test ruft nicht toString () auf, daher ist dies kein fairer Vergleich. Ich vermute, Sie werden feststellen, dass die Leistung der Verkettung innerhalb des Messfehlers liegt, wenn Sie diesen Fehler beheben.
Jamey Sharp
15
In den Verkettungs- und Formattests haben Sie nach a gefragt String. Der StringBuilder-Test benötigt, um fair zu sein, einen letzten Schritt, der den Inhalt des StringBuilder in einen String verwandelt. Sie tun dies, indem Sie anrufen bldString.toString(). Ich hoffe das erklärt es?
Jamey Sharp
4
Jamey Sharp ist genau richtig. Das Aufrufen von bldString.toString () ist ungefähr gleich, wenn nicht langsamer als die Verkettung von Zeichenfolgen.
Akos Cz
3
String s = bldString.toString(); Die Zeiten waren mit Verkettung und String fast gleichauf mit ihnen: Format = 1520 millisecond, Concatenation = 167 millisecond, String Builder = 173 millisecond Ich lief sie in einer Schleife und gemittelt jeweils aus einem guten rep zu erhalten: (pre-jvm - Optimierung, eine 10000+ Schleife versuchen , wenn ich Zeit habe)
TechTrip
3
Woher wisst ihr überhaupt, ob der Code überhaupt ausgeführt wird? Die Variablen werden niemals gelesen oder verwendet. Sie können nicht sicher sein, dass JIT diesen Code überhaupt nicht entfernt.
Alobodzk
37

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 von(nach dem die formatFunktion modelliert ist) ist lang und erschreckend.

Martin Schröder
quelle
16
Nur zur
Ron Klein,
2
Ein guter Punkt beim Kompilieren. Ich empfehle Ihnen, diese Überprüfungen über FindBugs durchzuführen (die während des Builds in der IDE oder über Maven ausgeführt werden können). Beachten Sie, dass dies auch die Formatierung in Ihrer gesamten Protokollierung überprüft! Dies funktioniert unabhängig von der Benutzer-IDE
Christophe Roussy
20

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.

Thilo
quelle
3
Genau. Das Nachdenken über Leistungsunterschiede ist hier hauptsächlich nur eine vorzeitige Optimierung. In dem unwahrscheinlichen Fall, dass die Profilerstellung zeigt, dass hier ein Problem vorliegt, machen Sie sich darüber Sorgen.
Jonik
3
Es ist wirklich nur eine Frage des persönlichen Geschmacks, wenn das Projekt klein ist und niemals in einem sinnvollen Sinne internationalisiert werden soll. Andernfalls setzt sich String.format in jeder Hinsicht gegen die Verkettung durch.
workmad3
4
Ich bin nicht einverstanden. Egal wie groß das Projekt ist, Sie werden kaum jeden String lokalisieren, der jemals darin erstellt wurde. Mit anderen Worten, es hängt von der Situation ab (wofür werden die Zeichenfolgen verwendet).
Jonik
Ich kann mir nicht vorstellen, wie irgendjemand jemals 'String.format ("% s% s", a, b)' als lesbarer als 'a + b' betrachten würde, wenn man den Geschwindigkeitsunterschied in der Größenordnung berücksichtigt Die Antwort scheint mir klar zu sein (in Situationen, in denen keine Lokalisierung erforderlich ist, wie z. B. Debug oder die meisten Protokollierungsanweisungen).
BobDoolittle
16

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
Derek Ziemba
quelle
1
StringBuilder ist die absolut schnellste Methode, wenn Sie Zeichen in einer Schleife anhängen, z. B. wenn Sie eine Zeichenfolge mit tausend Einsen erstellen möchten, indem Sie sie einzeln hinzufügen. Hier ist mehr Infos: pellegrino.link/2015/08/22/…
Carlos Hoyos
Mir gefällt, wie Sie immer String.format für die Ausgabe verwenden: D, also gibt es einen Vorteil. und um ehrlich zu sein, wenn wir nicht über Millionen von Iterationen sprechen, bevorzuge ich string.format für die Lesbarkeit, da Ihr Code den offensichtlichen Vorteil zeigt!
Mohamnag
9

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
Akos Cz
quelle
6

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.

Fortega
quelle
4

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.

Stephane Bersier
quelle
2

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.

AngerClown
quelle
2

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).

Pawel Zieminski
quelle
1

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.

Ganesa Vijayakumar
quelle
0

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.

DotNetUser
quelle
3
Hast du deinen Code ausprobiert? Die Verkettung ist immer zehnmal schneller
Icaro
Was ist mit den Millis, die benötigt werden, um dieses "System.currentTimeMillis ()" auszuführen: P.
Rehan
0

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 .

user665056
quelle