Czy lepiej jest używać Sznurka.formatowanie nad Konkatenacją łańcuchów w Javie?

O wydajności:

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");
}

Wyniki czasowe są następujące:

• konkatenacja = 265 milisekundy
• Format = 4141 milisekunda

Dlatego konkatenacja jest znacznie szybsza niż ciąg.format.

Ponieważ jest dyskusja na temat wydajności, pomyślałem, że dodam do porównania, które obejmowało StringBuilder. Jest w rzeczywistości szybszy niż concat i, oczywiście, struna.opcja formatowania.

Aby zrobić to coś w rodzaju porównania jabłek do jabłek, tworzę instancję nowego Stringbuildera w pętli, a nie na zewnątrz (jest to w rzeczywistości szybsze niż robienie tylko jednej instancji, najprawdopodobniej ze względu na narzut realokacji miejsca dla pętli na końcu jednego z nich budowniczy).

    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 milisekunda
• 2012-01-11 16:30:46,190 INFO [TestMain] - konkatenacja = 134 milisekunda
• 2012-01-11 16:30:46,313 INFO [TestMain] - String Builder = 117 milisekunda

Problem z .format polega na tym, że tracisz bezpieczeństwo typu statycznego. Możesz mieć zbyt mało argumentów dla swojego formatu i możesz mieć niewłaściwe typy dla specyfikatorów formatu - oba prowadzą do IllegalFormatException w czasie wykonywania , więc możesz skończyć z kodem logowania, który przerywa produkcję.

Natomiast argumenty + mogą być testowane przez kompilator.

Który z nich jest bardziej czytelny zależy od tego, jak działa Twoja głowa.

Konkatenacja łańcuchów jest nieznacznie szybsza, jak sądzę, ale to powinno być znikome.

Oto test z wieloma rozmiarami próbek w milisekundach.

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

Oto ten sam test jak wyżej z modyfikacją wywołania toString() metoda Na Stringbuilderze . Poniższe wyniki pokazują, że podejście StringBuilder jest nieco wolniejsze niż łączenie łańcuchów za pomocą + centrala.

Plik: StringTest.JPG / StringTestjava

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");

  }
}

polecenia powłoki: (skompiluj i uruchom StringTest 5 razy)

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

Wyniki :

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() to coś więcej niż tylko łączenie strun. Na przykład, możesz wyświetlać liczby w określonych lokalizacjach za pomocą String.format().

Jeśli jednak nie zależy ci na lokalizacji, nie ma żadnej różnicy funkcjonalnej. Może jeden jest szybszy od drugiego, ale w większości przypadków będzie znikomy..

Nie zrobiłem żadnych konkretnych benchmarków, ale myślę, że konkatenacja może być szybsza. Sznurek.format() tworzy nowy program formatujący, który z kolei tworzy nowy StringBuilder (o rozmiarze tylko 16 znaków). To spora ilość narzutu, zwłaszcza jeśli formatujesz dłuższy ciąg, a StringBuilder musi zmieniać rozmiar.

Jednak konkatenacja jest mniej użyteczna i trudniejsza do odczytania. Jak zawsze, warto zrobić benchmark na swoim kodzie, aby zobaczyć, który jest lepszy. Na różnice mogą być znikome w aplikacji serwera po pakietach zasobów, lokalizacjach itp. są ładowane do pamięci i Kod jest JITted.

Być może jako najlepsza praktyka, dobrym pomysłem byłoby stworzenie własnego Formatera z odpowiednio dobranym Stringbuilderem (Appendable) i Locale i użycie tego, jeśli masz dużo formatowania do zrobienia.

Może być zauważalna różnica.

String.format jest dość złożony i używa wyrażenia regularnego pod spodem, więc nie rób z tego nawyku używać go wszędzie, ale tylko tam, gdzie go potrzebujesz.

StringBuilder byłoby o rząd wielkości szybciej (jak ktoś tutaj już wskazał).

Ogólnie rzecz biorąc, konkatenacja łańcuchów powinna być preferowana zamiast String.format. Ten ostatni ma dwie główne wady:

1. nie koduje łańcucha znaków, który ma być zbudowany w sposób lokalny.
2. proces budowania jest zakodowany w łańcuchu znaków.

Przez punkt 1 mam na myśli, że nie można zrozumieć, co robi String.format() wywołanie w jednym sekwencyjnym przejściu. Jeden jest zmuszony do przechodzenia tam iz powrotem między łańcuchem formatu a argumentami, podczas liczenia pozycji argumentów. W przypadku krótkich konkatenacji nie jest to zbyt duży problem. W tych przypadkach jednak konkatenacja łańcuchów jest mniej wyrazista.

Przez punkt 2 mam na myśli, że ważna część procesu budowania jest zakodowana w formacie string (za pomocą DSL). Używanie ciągów znaków do reprezentowania kodu ma wiele wad. Nie jest z natury bezpieczny dla typu i komplikuje podświetlanie składni, analizę kodu, optymalizację itp.

Oczywiście przy użyciu narzędzi lub frameworków zewnętrznych do języka Java, w grę mogą wchodzić nowe czynniki.

Nie można porównywać konkatenacji łańcuchów i łańcuchów łańcuchowych.Formatowania według programu powyżej.

Możesz spróbować również zmienić pozycję używanego ciągu.Formatowanie i konkatenacja w bloku kodu jak poniżej

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") ;
}

Będziesz zaskoczony, widząc, że Format działa tutaj szybciej. Dzieje się tak, ponieważ utworzone obiekty intialne mogą nie zostać zwolnione i może wystąpić problem z alokacją pamięci, a tym samym wydajnością.